Implement EIP-7692

Author: gurukamath

setup.cfg

@@ -119,6 +119,7 @@ packages =
     ethereum/osaka
     ethereum/osaka/utils
     ethereum/osaka/vm
+    ethereum/osaka/vm/eof
     ethereum/osaka/vm/instructions
     ethereum/osaka/vm/precompiled_contracts
     ethereum/osaka/vm/precompiled_contracts/bls12_381

src/ethereum/osaka/fork.py

@@ -67,6 +67,7 @@
 from .utils.message import prepare_message
 from .vm import Message
 from .vm.eoa_delegation import is_valid_delegation
+from .vm.exceptions import InvalidEof
 from .vm.gas import (
     calculate_blob_gas_price,
     calculate_data_fee,
@@ -578,6 +579,7 @@ def process_system_transaction(
         accessed_addresses=set(),
         accessed_storage_keys=set(),
         parent_evm=None,
+        eof=None,
     )
 
     system_tx_output = process_message_call(system_tx_message)
@@ -796,9 +798,14 @@ def process_transaction(
         traces=[],
     )
 
-    message = prepare_message(block_env, tx_env, tx)
-
-    tx_output = process_message_call(message)
+    try:
+        message = prepare_message(block_env, tx_env, tx)
+    except InvalidEof as error:
+        tx_output = MessageCallOutput(
+            gas, U256(0), tuple(), set(), set(), error, b""
+        )
+    else:
+        tx_output = process_message_call(message)
 
     # For EIP-7623 we first calculate the execution_gas_used, which includes
     # the execution gas refund.

src/ethereum/osaka/utils/address.py

@@ -23,6 +23,8 @@
 
 from ..fork_types import Address
 
+MAX_ADDRESS_U256 = U256.from_be_bytes(b"\xff" * 20)
+
 
 def to_address(data: Union[Uint, U256]) -> Address:
     """
@@ -41,9 +43,35 @@ def to_address(data: Union[Uint, U256]) -> Address:
     return Address(data.to_be_bytes32()[-20:])
 
 
+def to_address_without_mask(data: U256) -> Address:
+    """
+    Convert a Uint or U256 value to a valid address (20 bytes).
+    Raises a `ValueError` if the data is larger than `MAX_ADDRESS_U256
+
+    Parameters
+    ----------
+    data :
+        The string to be converted to bytes.
+
+    Raises
+    ------
+    ValueError
+        If `data` is larger than `MAX_ADDRESS_U256`.
+
+    Returns
+    -------
+    address : `Address`
+        The obtained address.
+    """
+    if data > MAX_ADDRESS_U256:
+        raise ValueError("Address is too large")
+    return Address(data.to_be_bytes32()[-20:])
+
+
 def compute_contract_address(address: Address, nonce: Uint) -> Address:
     """
-    Computes address of the new account that needs to be created.
+    Computes address of the new account that needs to be created based
+    on the account nonce.
 
     Parameters
     ----------

src/ethereum/osaka/utils/message.py

@@ -20,6 +20,9 @@
 from ..transactions import Transaction
 from ..vm import BlockEnvironment, Message, TransactionEnvironment
 from ..vm.eoa_delegation import get_delegated_code_address
+from ..vm.eof import ContainerContext, Eof, EofVersion, get_eof_version
+from ..vm.eof.utils import metadata_from_container
+from ..vm.eof.validation import parse_create_tx_call_data
 from ..vm.precompiled_contracts.mapping import PRE_COMPILED_CONTRACTS
 from .address import compute_contract_address
 
@@ -56,8 +59,13 @@ def prepare_message(
             tx_env.origin,
             get_account(block_env.state, tx_env.origin).nonce - Uint(1),
         )
-        msg_data = Bytes(b"")
-        code = tx.data
+        if get_eof_version(tx.data) == EofVersion.LEGACY:
+            msg_data = Bytes(b"")
+            code = tx.data
+            eof = None
+        else:
+            eof, msg_data = parse_create_tx_call_data(tx.data)
+            code = eof.container
         code_address = None
     elif isinstance(tx.to, Address):
         current_target = tx.to
@@ -70,6 +78,20 @@ def prepare_message(
             code = get_account(block_env.state, delegated_address).code
 
         code_address = tx.to
+
+        if get_eof_version(code) == EofVersion.LEGACY:
+            eof = None
+        else:
+            metadata = metadata_from_container(
+                code,
+                validate=False,
+                context=ContainerContext.RUNTIME,
+            )
+            eof = Eof(
+                version=get_eof_version(code),
+                container=code,
+                metadata=metadata,
+            )
     else:
         raise AssertionError("Target must be address or empty bytes")
 
@@ -92,4 +114,5 @@ def prepare_message(
         accessed_addresses=accessed_addresses,
         accessed_storage_keys=set(tx_env.access_list_storage_keys),
         parent_evm=None,
+        eof=eof,
     )

src/ethereum/osaka/vm/__init__.py

@@ -14,7 +14,7 @@
 """
 
 from dataclasses import dataclass, field
-from typing import List, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING, List, Optional, Set, Tuple, Union
 
 from ethereum_types.bytes import Bytes, Bytes0, Bytes32
 from ethereum_types.numeric import U64, U256, Uint
@@ -29,9 +29,16 @@
 from ..trie import Trie
 from .precompiled_contracts import RIPEMD160_ADDRESS
 
+if TYPE_CHECKING:
+    from .eof import Eof, ReturnStackItem
+
+
 __all__ = ("Environment", "Evm", "Message")
 
 
+MAX_CODE_SIZE = 0x6000
+
+
 @dataclass
 class BlockEnvironment:
     """
@@ -132,6 +139,7 @@ class Message:
     accessed_addresses: Set[Address]
     accessed_storage_keys: Set[Tuple[Address, Bytes32]]
     parent_evm: Optional["Evm"]
+    eof: Optional["Eof"]
 
 
 @dataclass
@@ -155,6 +163,10 @@ class Evm:
     error: Optional[EthereumException]
     accessed_addresses: Set[Address]
     accessed_storage_keys: Set[Tuple[Address, Bytes32]]
+    eof: Optional["Eof"]
+    current_section_index: Uint
+    return_stack: List["ReturnStackItem"]
+    deploy_container: Optional[Bytes]
 
 
 def incorporate_child_on_success(evm: Evm, child_evm: Evm) -> None:

src/ethereum/osaka/vm/eof/__init__.py

@@ -0,0 +1,165 @@
+"""
+Ethereum Object Format (EOF)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. contents:: Table of Contents
+    :backlinks: none
+    :local:
+
+Introduction
+------------
+
+Implementation of the Ethereum Object Format (EOF) specification.
+"""
+
+import enum
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Set
+
+from ethereum_types.bytes import Bytes
+from ethereum_types.numeric import Uint
+
+from ..exceptions import InvalidEof
+
+EOF_MAGIC = b"\xEF\x00"
+EOF_MAGIC_LENGTH = len(EOF_MAGIC)
+
+
+class EofVersion(enum.Enum):
+    """
+    Enumeration of the different kinds of EOF containers.
+    Legacy code is assigned zero.
+    """
+
+    LEGACY = 0
+    EOF1 = 1
+
+
+class ContainerContext(enum.Enum):
+    """
+    The context of the container. Create transaction
+    data / init / account code / sub-container.
+    A sub-container can either be an EOFCREATE target (init)
+    or a RETURNCONTRACT target.
+    """
+
+    CREATE_TX_DATA = 0
+    INIT = 1
+    RUNTIME = 2
+    RETURNCONTRACT_TARGET = 3
+
+
+@dataclass
+class EofMetadata:
+    """
+    Dataclass to hold the metadata information of the
+    EOF container.
+    """
+
+    context: ContainerContext
+    type_size: Uint
+    num_code_sections: Uint
+    code_sizes: List[Uint]
+    num_container_sections: Uint
+    container_sizes: List[Uint]
+    data_size: Uint
+    body_start_index: Uint
+    type_section_contents: List[bytes]
+    code_section_contents: List[bytes]
+    container_section_contents: List[bytes]
+    data_section_contents: bytes
+
+
+@dataclass
+class Eof:
+    """
+    Dataclass to hold the EOF container information.
+    """
+
+    version: EofVersion
+    container: Bytes
+    metadata: EofMetadata
+
+
+@dataclass
+class ReturnStackItem:
+    """
+    Stack item for the return stack.
+    """
+
+    code_section_index: Uint
+    offset: Uint
+
+
+@dataclass
+class OperandStackHeight:
+    """
+    Stack height bounds of an instruction.
+    """
+
+    min: int
+    max: int
+
+
+@dataclass
+class InstructionMetadata:
+    """
+    Metadata of an instruction in the code section.
+    """
+
+    from ..instructions import Ops
+
+    opcode: Ops
+    pc_post_instruction: Uint
+    relative_offsets: List[int]
+    target_index: Optional[Uint]
+    container_index: Optional[Uint]
+    stack_height: Optional[OperandStackHeight]
+
+
+SectionMetadata = Dict[Uint, InstructionMetadata]
+
+
+@dataclass
+class Validator:
+    """
+    Validator for the Ethereum Object Format (EOF) container.
+    """
+
+    from ..instructions import Ops
+
+    eof: Eof
+    sections: Dict[Uint, SectionMetadata]
+    current_index: Uint
+    current_code: bytes
+    current_pc: Uint
+    is_current_section_returning: bool
+    has_return_contract: bool
+    has_stop: bool
+    has_return: bool
+    reached_code_sections: List[Set[Uint]]
+    referenced_subcontainers: Dict[Ops, List[Uint]]
+    current_stack_height: Optional[OperandStackHeight]
+
+
+def get_eof_version(code: bytes) -> EofVersion:
+    """
+    Get the Eof container's version.
+
+    Parameters
+    ----------
+    code : bytes
+        The code to check.
+
+    Returns
+    -------
+    Eof
+        Eof Version of the container.
+    """
+    if not code.startswith(EOF_MAGIC):
+        return EofVersion.LEGACY
+
+    if code[EOF_MAGIC_LENGTH] == 1:
+        return EofVersion.EOF1
+    else:
+        raise InvalidEof("Invalid EOF version")