Implement EIP-7904

[LouisTsai-Csie]

🗒️ Description

Detailed background in this issue.

Basic concept is that we extract all the gas cost value into one configuration file, such as gas_costs.yaml. It would be the gas cost data source for both specs & tests.

Two major benefit:

• external contributor (e.g. Kamil, Maria, Marius who works on gas repricing) could use this config as a reference for gas cost, and only one file required to update if we want to benchmark different values.
• We could use gas table to create a fork dependent gas calculator in our testing framework, details in this issue.

More details for the changes:

• I first update Osaka fork for verification before moving on gas repricing stuff: Define gas_cost.yaml and loaded as an GasCosts object via script in constant.py(both under src/ethereum/forks/osaka/utils/).
• Update all the gas cost definition in src/ethereum/forks/osaka/vm. Take ADD for example , we replace charge_gas(evm, G.G_LOW) with charge_gas(evm, G.ADD). This is applied to every opcode.
• Pass the gas cost data class from step 2 to test framework in packages/tests/src/ethereum_test_forks/forks.py::gas_costs.
• Create a new fork for gas repricing, and update the gas category defined in eip-7904.

🔗 Related Issues or PRs

Issue #1479
Issue #1599
EIP-7904: https://eips.ethereum.org/EIPS/eip-7904

✅ Checklist

• All: Ran fast tox checks to avoid unnecessary CI fails, see also Code Standards and Enabling Pre-commit Checks:

  uvx tox -e static

• All: PR title adheres to the repo standard - it will be used as the squash commit message and should start type(scope):.
• All: Considered adding an entry to CHANGELOG.md.
• All: Considered updating the online docs in the ./docs/ directory.
• All: Set appropriate labels for the changes (only maintainers can apply labels).
• Tests: Ran mkdocs serve locally and verified the auto-generated docs for new tests in the Test Case Reference are correctly formatted.
• Tests: For PRs implementing a missed test case, update the post-mortem document to add an entry the list.
• Ported Tests: All converted JSON/YML tests from ethereum/tests or tests/static have been assigned @ported_from marker.

Cute Animal Picture

[SamWilsn]

We try to maintain the simplest possible implementation in the spec itself. Adding a class to load from a file is significantly more complex than using native Python constants.

It also breaks "Jump to Definition" in IDEs (and docc), so would make discovering the value of a constant that much more difficult.

All that said, I do see the value in making gas pricing available outside of the spec without having to import an entire Python interpreter. On the flip side, I'm not sure updating a YAML file is that much easier than updating a Python file if you want to play with different gas prices while executing the spec.

I think my preferred solution to this would be to have a very strictly formatted gas.py and provide an algorithm to parse it (and a test to ensure that the python version matches the manually parsed version). Something like:

gas.py

# Named Constants
BASE = Uint(2)
"""
Cost of the simplest EVM instructions.
"""

VERY_LOW = Uint(3)
"""
Cost of common EVM instructions.
"""

# Instruction Costs
OP_STOP = BASE
"""
Cost of the [STOP](ref:ethereum.forks.frontier.vm...) instruction.
"""

Parsing

Provide a regular expression that matches something like (?P<key>[^ ]+) = (?P<value>.*).

[SamWilsn]

You should use importlib.resources when accessing data files.

[SamWilsn]

Please no.

[SamWilsn]

The specs themselves are always the reference. Any relevant information should be moved into this file.

[SamWilsn]

Why keep these as separate dicts?

[SamWilsn]

Suggested change

	if opcode in self._opcode_values_cache:
	return self._opcode_values_cache[opcode]
	raise KeyError(f"Opcode '{opcode}' not found")
	try:
	return self._opcode_values_cache[opcode]
	except KeyError as e:
	raise KeyError(f"Opcode '{opcode}' not found") from e

[SamWilsn]

Prefer omitting get_ prefix for getters.

[SamWilsn]

If you're going to use YAML, you could use anchors to implement the symbolic gas costs. Would make the parsing side a bit easier. Something like:

STOP: &BASE_OPCODE_COST 1
ADD: *BASE_OPCODE_COST
MUL: *BASE_OPCODE_COST

# And so on...

[LouisTsai-Csie]

@SamWilsn I agree the yaml format introduces unnecessary complexity to the spec, the original idea is to integrate pitsop, but we do not need this anymore (due to safety reason).

I create a new structure and have some prototype, it is not working now and need more refactoring.

Unify the gas cost variable and category between EELS and EEST:

• This is the preliminary analysis of the variables. We could replace all the EEST variable with EELS naming, which require less effort.
• Use specs as the only data source for the gas variable: Move the EEST-specific variable to EELS.
• Create a new file, opcode.py (or constant.py), which contains all the opcode gas category and the gas table for opcodes, while other gas cost remains in gas.py.

This change will minimize the effort required, and now dev that works on gas repricing could use opcode.py as the single source of data.

Some example changes:

opcode.py: This would be the single source of data for the opcode gas cost (excluding additional overhead like memory extension or warm/cold storage access, address access cost).

# Opcode Gas Category
AS_JUMPDEST = Uint(1)
GAS_BASE = Uint(2)
...

# Opcode gas cost table
OP_STOP = GAS_BASE
OP_ADD = GAS_VERY_LOW
...

gas.py: This would contain other gas cost variable other than the opcode gas cost

from .constant import (
    GAS_BASE,
    GAS_JUMPDEST,
    ...
)
from .exceptions import OutOfGasError

# Opcode Gas Category
## Import from opcode.py
GAS_JUMPDEST = GAS_JUMPDEST
GAS_BASE = GAS_BASE
....

# Other gas variable
GAS_STORAGE_UPDATE = Uint(5000)
GAS_STORAGE_CLEAR_REFUND = Uint(4800)
....

arithmetirc.py: Display as an example how to access the opcode gas cost

# Import the opcode gas cost for ADD
from ..constant import (
    OP_ADD,
    ...
)
from ..gas import (
     ...,
    charge_gas,
)

def add(evm: Evm) -> None:
   ...
    x = pop(evm.stack)
    y = pop(evm.stack)

    # access the opcode gas here
    charge_gas(evm, OP_ADD)

    result = x.wrapping_add(y)
    push(evm.stack, result)
    evm.pc += Uint(1)

forks.py: In EEST, we read the variable from EELS, this would be helpful as we could define a new function: op_costs for each forks, thus creating a fork dependent gas table.

@classmethod
def gas_costs(
    cls, *, block_number: int = 0, timestamp: int = 0
) -> GasCosts:
    """Return the gas costs for the fork."""
    from ethereum.forks.osaka.vm import gas as g
    from dataclasses import fields

    # Build kwargs by matching GasCosts field names with gas module variables
    kwargs = {}
    for field in fields(GasCosts):
        if hasattr(g, field.name):
            kwargs[field.name] = getattr(g, field.name)

    return GasCosts(**kwargs)

[LouisTsai-Csie]

Define the gas cost category here, which will be later imported in gas.py at the same folder level.

Define the gas cost below like:

OP_STOP = GAS_BASE
OP_ADD = GAS_VERY_LOW
OP_MUL = GAS_LOW
...

Rationale: Dev could use this as the opcode gas reference

[LouisTsai-Csie]

re-import the gas cost category from gas.py

[LouisTsai-Csie]

Replace the opcode gas cost:

- charge_gas(evm, GAS_VERY_LOW)
+ charge_gas(evm, OP_ADD)

In this case, if the gas cost for ADD is updated, we do not need to update this file but only opcode.py (or constant.py, naming TBD)

[LouisTsai-Csie]

We could import the variable in EEST like this, and create a new function for opcode cost. With this, we have a fork dependent gas table

[LouisTsai-Csie]

There are still a lot of changes required - but would be helpful to receive some feedback for this format.

[LouisTsai-Csie]

Closed, in favor of PR #1776