diff --git a/.github/configs/feature.yaml b/.github/configs/feature.yaml index 5c17c3bb3e7..cd8f4300039 100644 --- a/.github/configs/feature.yaml +++ b/.github/configs/feature.yaml @@ -9,3 +9,7 @@ monad: # (triggered by tarball output) fails to proceed on no tests processed # in 1st phase (exit code 5) fill-params: --suppress-no-test-exit-code -m blockchain_test --from=MONAD_EIGHT --until=MONAD_NINE --chain-id=143 -k "not invalid_header" + +monad_amsterdam: + evm-type: eels + fill-params: --suppress-no-test-exit-code -m blockchain_test --fork=MONAD_NEXT --chain-id=143 -k "not invalid_header" tests/amsterdam/eip7708_eth_transfer_logs tests/amsterdam/eip7843_slotnum tests/amsterdam/eip8024_dupn_swapn_exchange diff --git a/packages/testing/src/execution_testing/forks/forks/forks.py b/packages/testing/src/execution_testing/forks/forks/forks.py index fd0a848f10d..94a553aacc3 100644 --- a/packages/testing/src/execution_testing/forks/forks/forks.py +++ b/packages/testing/src/execution_testing/forks/forks/forks.py @@ -1666,8 +1666,111 @@ def c(w: int) -> int: return fn -class MONAD_NEXT(MONAD_NINE, solc_name="cancun"): # noqa: N801 - """MONAD_NEXT fork.""" +class BPO1( + Osaka, + bpo_fork=True, + update_blob_constants={ + "BLOB_BASE_FEE_UPDATE_FRACTION": 8346193, + "TARGET_BLOBS_PER_BLOCK": 10, + "MAX_BLOBS_PER_BLOCK": 15, + }, +): + """Mainnet BPO1 fork - Blob Parameter Only fork 1.""" + + pass + + +class BPO2( + BPO1, + bpo_fork=True, + update_blob_constants={ + "BLOB_BASE_FEE_UPDATE_FRACTION": 11684671, + "TARGET_BLOBS_PER_BLOCK": 14, + "MAX_BLOBS_PER_BLOCK": 21, + }, +): + """Mainnet BPO2 fork - Blob Parameter Only fork 2.""" + + pass + + +class BPO3( + BPO2, + bpo_fork=True, + deployed=False, + update_blob_constants={ + "BLOB_BASE_FEE_UPDATE_FRACTION": 20609697, + "TARGET_BLOBS_PER_BLOCK": 21, + "MAX_BLOBS_PER_BLOCK": 32, + }, +): + """ + Pseudo BPO3 fork - Blob Parameter Only fork 3. + For testing purposes only. + """ + + pass + + +class BPO4( + BPO3, + bpo_fork=True, + update_blob_constants={ + "BLOB_BASE_FEE_UPDATE_FRACTION": 13739630, + "TARGET_BLOBS_PER_BLOCK": 14, + "MAX_BLOBS_PER_BLOCK": 21, + }, +): + """ + Pseudo BPO4 fork - Blob Parameter Only fork 4. + For testing purposes only. Testing a decrease in values from BPO3. + """ + + pass + + +class BPO5( + BPO4, + bpo_fork=True, +): + """ + Pseudo BPO5 fork - Blob Parameter Only fork 5. + For testing purposes only. Required to parse Fusaka devnet genesis files. + """ + + pass + + +class Amsterdam( + AmsterdamEIPs, + BPO2, + deployed=False, +): + """Amsterdam fork.""" + + # TODO: We may need to adjust which BPO Amsterdam inherits from as the + # related Amsterdam specs change over time, and before Amsterdam is + # live on mainnet. + + pass + + +class MONAD_NEXT(MONAD_NINE, Amsterdam, solc_name="cancun"): # noqa: N801 + """ + MONAD_NEXT fork. + + Amsterdam-based successor to MONAD_NINE. Only the EIP-7708, EIP-7843 + and EIP-8024 changes are inherited from Amsterdam; every other + Amsterdam change is pinned back to the MONAD_NINE parent. + """ + + @classmethod + def valid_opcodes(cls) -> List[Opcodes]: + """ + Inherit the Amsterdam opcode set: SLOTNUM (EIP-7843) and SWAPN, + DUPN, EXCHANGE (EIP-8024) on top of the MONAD_NINE opcodes. + """ + return Amsterdam.valid_opcodes() @classmethod def gas_costs(cls) -> GasCosts: @@ -1753,91 +1856,50 @@ def _calculate_sstore_gas_mip8( return gas_cost + @classmethod + def max_code_size(cls) -> int: + """Return spec from explicit parent (skip EIP-7954).""" + return MONAD_NINE.max_code_size() -class BPO1( - Osaka, - bpo_fork=True, - update_blob_constants={ - "BLOB_BASE_FEE_UPDATE_FRACTION": 8346193, - "TARGET_BLOBS_PER_BLOCK": 10, - "MAX_BLOBS_PER_BLOCK": 15, - }, -): - """Mainnet BPO1 fork - Blob Parameter Only fork 1.""" - - pass - - -class BPO2( - BPO1, - bpo_fork=True, - update_blob_constants={ - "BLOB_BASE_FEE_UPDATE_FRACTION": 11684671, - "TARGET_BLOBS_PER_BLOCK": 14, - "MAX_BLOBS_PER_BLOCK": 21, - }, -): - """Mainnet BPO2 fork - Blob Parameter Only fork 2.""" - - pass - - -class BPO3( - BPO2, - bpo_fork=True, - deployed=False, - update_blob_constants={ - "BLOB_BASE_FEE_UPDATE_FRACTION": 20609697, - "TARGET_BLOBS_PER_BLOCK": 21, - "MAX_BLOBS_PER_BLOCK": 32, - }, -): - """ - Pseudo BPO3 fork - Blob Parameter Only fork 3. - For testing purposes only. - """ - - pass - - -class BPO4( - BPO3, - bpo_fork=True, - update_blob_constants={ - "BLOB_BASE_FEE_UPDATE_FRACTION": 13739630, - "TARGET_BLOBS_PER_BLOCK": 14, - "MAX_BLOBS_PER_BLOCK": 21, - }, -): - """ - Pseudo BPO4 fork - Blob Parameter Only fork 4. - For testing purposes only. Testing a decrease in values from BPO3. - """ - - pass + @classmethod + def calldata_gas_calculator(cls) -> CalldataGasCalculator: + """Return spec from explicit parent (skip EIP-7976).""" + return MONAD_NINE.calldata_gas_calculator() + @classmethod + def transaction_data_floor_cost_calculator( + cls, + ) -> TransactionDataFloorCostCalculator: + """Return spec from explicit parent (skip EIP-7981).""" + return MONAD_NINE.transaction_data_floor_cost_calculator() -class BPO5( - BPO4, - bpo_fork=True, -): - """ - Pseudo BPO5 fork - Blob Parameter Only fork 5. - For testing purposes only. Required to parse Fusaka devnet genesis files. - """ + @classmethod + def transaction_intrinsic_cost_calculator( + cls, + ) -> TransactionIntrinsicCostCalculator: + """Return spec from explicit parent (skip EIP-7981).""" + return MONAD_NINE.transaction_intrinsic_cost_calculator() - pass + @classmethod + def header_bal_hash_required(cls) -> bool: + """Return spec from explicit parent (skip EIP-7928).""" + return MONAD_NINE.header_bal_hash_required() + @classmethod + def empty_block_bal_item_count(cls) -> int: + """Return spec from explicit parent (skip EIP-7928).""" + return MONAD_NINE.empty_block_bal_item_count() -class Amsterdam( - AmsterdamEIPs, - BPO2, - deployed=False, -): - """Amsterdam fork.""" + @classmethod + def engine_execution_payload_block_access_list(cls) -> bool: + """Return spec from explicit parent (skip EIP-7928).""" + return MONAD_NINE.engine_execution_payload_block_access_list() - # TODO: We may need to adjust which BPO Amsterdam inherits from as the - # related Amsterdam specs change over time, and before Amsterdam is - # live on mainnet. - pass +# MONAD_NEXT adopts EIP-7708, EIP-7843 and EIP-8024 from Amsterdam through the +# MRO rather than by inheriting their mixin classes: inheriting them would +# register MONAD_NEXT as a spurious `enabling_fork` (breaking +# `valid_at_transition_to`) and pull in EIP-7843's engine version bumps. +# Record the adopted EIP numbers on `_enabled_eips` directly so that +# `is_eip_enabled()` reports them without those side effects. +MONAD_NEXT._enabled_eips |= {7708, 7843, 8024} diff --git a/src/ethereum/forks/monad_next/blocks.py b/src/ethereum/forks/monad_next/blocks.py index f6745f79de3..4d83d39df9e 100644 --- a/src/ethereum/forks/monad_next/blocks.py +++ b/src/ethereum/forks/monad_next/blocks.py @@ -248,6 +248,14 @@ class Header: [SHA2-256]: https://en.wikipedia.org/wiki/SHA-2 """ + slot_number: U64 + """ + The slot number of this block as provided by the consensus layer. + Introduced in [EIP-7843]. + + [EIP-7843]: https://eips.ethereum.org/EIPS/eip-7843 + """ + @final @slotted_freezable diff --git a/src/ethereum/forks/monad_next/fork.py b/src/ethereum/forks/monad_next/fork.py index d8284e126c5..310036c2471 100644 --- a/src/ethereum/forks/monad_next/fork.py +++ b/src/ethereum/forks/monad_next/fork.py @@ -42,6 +42,7 @@ State, apply_changes_to_state, ) +from ethereum.utils.byte import left_pad_zero_bytes from . import vm from .blocks import Block, Header, Log, Receipt, Withdrawal, encode_receipt @@ -294,6 +295,7 @@ def state_transition(chain: BlockChain, block: Block) -> None: prev_randao=block.header.prev_randao, excess_blob_gas=block.header.excess_blob_gas, parent_beacon_block_root=block.header.parent_beacon_block_root, + slot_number=block.header.slot_number, ) block_output = apply_body( @@ -1019,15 +1021,32 @@ def process_transaction( # transfer miner fees create_ether(tx_state, block_env.coinbase, U256(transaction_fee)) - for address in tx_output.accounts_to_delete: - destroy_account(tx_state, address) + # EIP-7708: Emit burn logs for balances held by accounts marked for + # deletion AFTER miner fee transfer. + finalization_logs: List[Log] = [] + for address in sorted(tx_output.accounts_to_delete): + balance = get_account(tx_state, address).balance + if balance > U256(0): + padded_address = left_pad_zero_bytes(address, 32) + finalization_logs.append( + Log( + address=vm.SYSTEM_ADDRESS, + topics=( + vm.BURN_TOPIC, + Hash32(padded_address), + ), + data=balance.to_be_bytes32(), + ) + ) + + all_logs = tx_output.logs + tuple(finalization_logs) # block_output.block_gas_used += tx_gas_used_after_refund block_output.block_gas_used += tx.gas block_output.blob_gas_used += tx_blob_gas_used receipt = make_receipt( - tx, tx_output.error, block_output.block_gas_used, tx_output.logs + tx, tx_output.error, block_output.block_gas_used, all_logs ) receipt_key = rlp.encode(Uint(index)) @@ -1039,7 +1058,10 @@ def process_transaction( receipt, ) - block_output.block_logs += tx_output.logs + block_output.block_logs += all_logs + + for address in tx_output.accounts_to_delete: + destroy_account(tx_state, address) incorporate_tx_into_block(tx_state) diff --git a/src/ethereum/forks/monad_next/vm/__init__.py b/src/ethereum/forks/monad_next/vm/__init__.py index 5738e4f0d5f..0d018d625b7 100644 --- a/src/ethereum/forks/monad_next/vm/__init__.py +++ b/src/ethereum/forks/monad_next/vm/__init__.py @@ -18,10 +18,11 @@ from ethereum_types.bytes import Bytes, Bytes0, Bytes32 from ethereum_types.numeric import U64, U256, Uint -from ethereum.crypto.hash import Hash32 +from ethereum.crypto.hash import Hash32, keccak256 from ethereum.exceptions import EthereumException from ethereum.merkle_patricia_trie import Trie from ethereum.state import Address +from ethereum.utils.byte import left_pad_zero_bytes from ..blocks import Log, Receipt, Withdrawal from ..fork_types import Authorization, VersionedHash @@ -30,6 +31,12 @@ __all__ = ("Environment", "Evm", "Message") +TRANSFER_TOPIC = keccak256(b"Transfer(address,address,uint256)") +BURN_TOPIC = keccak256(b"Burn(address,uint256)") +SYSTEM_ADDRESS = Address( + bytes.fromhex("fffffffffffffffffffffffffffffffffffffffe") +) + @final @dataclass @@ -49,6 +56,7 @@ class BlockEnvironment: prev_randao: Bytes32 excess_blob_gas: U64 parent_beacon_block_root: Hash32 + slot_number: U64 @final @@ -236,3 +244,76 @@ def incorporate_child_on_error(evm: Evm, child_evm: Evm) -> None: # NOTE: absence of `evm.memory`, in particular of its high watermark # is intended for memory to deallocate on call frame exit. + + +def emit_transfer_log( + evm: Evm, + sender: Address, + recipient: Address, + transfer_amount: U256, +) -> None: + """ + Emit a LOG3 for all ETH transfers satisfying EIP-7708. + + Parameters + ---------- + evm : + The state of the ethereum virtual machine + sender : + The account address sending the transfer + recipient : + The account address receiving the transfer + transfer_amount : + The amount of ETH transacted + + """ + if transfer_amount == 0: + return + + padded_sender = left_pad_zero_bytes(sender, 32) + padded_recipient = left_pad_zero_bytes(recipient, 32) + log_entry = Log( + address=SYSTEM_ADDRESS, + topics=( + TRANSFER_TOPIC, + Hash32(padded_sender), + Hash32(padded_recipient), + ), + data=transfer_amount.to_be_bytes32(), + ) + + evm.logs = evm.logs + (log_entry,) + + +def emit_burn_log( + evm: Evm, + account: Address, + amount: U256, +) -> None: + """ + Emit a LOG2 for ETH burn per EIP-7708. + + Parameters + ---------- + evm : + The state of the ethereum virtual machine + account : + The account address whose ETH is being burned + amount : + The amount of ETH being burned + + """ + if amount == 0: + return + + padded_account = left_pad_zero_bytes(account, 32) + log_entry = Log( + address=SYSTEM_ADDRESS, + topics=( + BURN_TOPIC, + Hash32(padded_account), + ), + data=amount.to_be_bytes32(), + ) + + evm.logs = evm.logs + (log_entry,) diff --git a/src/ethereum/forks/monad_next/vm/gas.py b/src/ethereum/forks/monad_next/vm/gas.py index 870cee592ac..461f0f79a27 100644 --- a/src/ethereum/forks/monad_next/vm/gas.py +++ b/src/ethereum/forks/monad_next/vm/gas.py @@ -189,11 +189,15 @@ class GasCosts: OPCODE_CHAINID: Final[Uint] = BASE OPCODE_BASEFEE: Final[Uint] = BASE OPCODE_BLOBBASEFEE: Final[Uint] = BASE + OPCODE_SLOTNUM: Final[Uint] = BASE OPCODE_BLOBHASH: Final[Uint] = Uint(3) OPCODE_PUSH: Final[Uint] = VERY_LOW OPCODE_PUSH0: Final[Uint] = BASE OPCODE_DUP: Final[Uint] = VERY_LOW OPCODE_SWAP: Final[Uint] = VERY_LOW + OPCODE_DUPN: Final[Uint] = VERY_LOW + OPCODE_SWAPN: Final[Uint] = VERY_LOW + OPCODE_EXCHANGE: Final[Uint] = VERY_LOW # Dynamic Opcodes OPCODE_RETURNDATACOPY_BASE: Final[Uint] = VERY_LOW diff --git a/src/ethereum/forks/monad_next/vm/instructions/__init__.py b/src/ethereum/forks/monad_next/vm/instructions/__init__.py index 0da72c8ea5c..06295ec86f1 100644 --- a/src/ethereum/forks/monad_next/vm/instructions/__init__.py +++ b/src/ethereum/forks/monad_next/vm/instructions/__init__.py @@ -99,6 +99,7 @@ class Ops(enum.Enum): BASEFEE = 0x48 BLOBHASH = 0x49 BLOBBASEFEE = 0x4A + SLOTNUM = 0x4B # Control Flow Ops STOP = 0x00 @@ -188,6 +189,11 @@ class Ops(enum.Enum): SWAP15 = 0x9E SWAP16 = 0x9F + # EIP-8024: Stack access instructions + DUPN = 0xE6 + SWAPN = 0xE7 + EXCHANGE = 0xE8 + # Memory Operations MLOAD = 0x51 MSTORE = 0x52 @@ -251,6 +257,7 @@ class Ops(enum.Enum): Ops.PREVRANDAO: block_instructions.prev_randao, Ops.GASLIMIT: block_instructions.gas_limit, Ops.CHAINID: block_instructions.chain_id, + Ops.SLOTNUM: block_instructions.slot_number, Ops.MLOAD: memory_instructions.mload, Ops.MSTORE: memory_instructions.mstore, Ops.MSTORE8: memory_instructions.mstore8, @@ -350,6 +357,9 @@ class Ops(enum.Enum): Ops.SWAP14: stack_instructions.swap14, Ops.SWAP15: stack_instructions.swap15, Ops.SWAP16: stack_instructions.swap16, + Ops.DUPN: stack_instructions.dupn, + Ops.SWAPN: stack_instructions.swapn, + Ops.EXCHANGE: stack_instructions.exchange, Ops.LOG0: log_instructions.log0, Ops.LOG1: log_instructions.log1, Ops.LOG2: log_instructions.log2, diff --git a/src/ethereum/forks/monad_next/vm/instructions/block.py b/src/ethereum/forks/monad_next/vm/instructions/block.py index baa589c4395..4f9f9e5d5c3 100644 --- a/src/ethereum/forks/monad_next/vm/instructions/block.py +++ b/src/ethereum/forks/monad_next/vm/instructions/block.py @@ -259,3 +259,36 @@ def chain_id(evm: Evm) -> None: # PROGRAM COUNTER evm.pc += Uint(1) + + +def slot_number(evm: Evm) -> None: + """ + Push the current slot number onto the stack. + + The slot number is provided by the consensus layer and passed to the + execution layer through the engine API. + + Parameters + ---------- + evm : + The current EVM frame. + + Raises + ------ + :py:class:`~ethereum.forks.monad_next.vm.exceptions.StackOverflowError` + If `len(stack)` is equal to `1024`. + :py:class:`~ethereum.forks.monad_next.vm.exceptions.OutOfGasError` + If `evm.gas_left` is less than `2`. + + """ + # STACK + pass + + # GAS + charge_gas(evm, GasCosts.OPCODE_SLOTNUM) + + # OPERATION + push(evm.stack, U256(evm.message.block_env.slot_number)) + + # PROGRAM COUNTER + evm.pc += Uint(1) diff --git a/src/ethereum/forks/monad_next/vm/instructions/stack.py b/src/ethereum/forks/monad_next/vm/instructions/stack.py index ce94af6ce8e..0e72bd01f31 100644 --- a/src/ethereum/forks/monad_next/vm/instructions/stack.py +++ b/src/ethereum/forks/monad_next/vm/instructions/stack.py @@ -14,7 +14,7 @@ from functools import partial from typing import Callable -from ethereum_types.numeric import U256, Uint +from ethereum_types.numeric import U8, U256, Uint from .. import Evm, stack from ..exceptions import StackUnderflowError @@ -23,6 +23,7 @@ charge_gas, ) from ..memory import buffer_read +from ..stack import decode_pair, decode_single def pop(evm: Evm) -> None: @@ -210,3 +211,107 @@ def swap_n(evm: Evm, item_number: int) -> None: swap14: Callable[[Evm], None] = partial(swap_n, item_number=14) swap15: Callable[[Evm], None] = partial(swap_n, item_number=15) swap16: Callable[[Evm], None] = partial(swap_n, item_number=16) + + +def dupn(evm: Evm) -> None: + """ + Duplicate the Nth stack item (from top of the stack) to the top of stack. + The item number is read from the immediate byte following the opcode and + decoded using the EIP-8024 index shifting rules. + + Parameters + ---------- + evm : + The current EVM frame. + + """ + # STACK + pass + + # GAS + charge_gas(evm, GasCosts.OPCODE_DUPN) + + # OPERATION + immediate_data = U8( + buffer_read(evm.code, U256(evm.pc + Uint(1)), U256(1))[0] + ) + item_number = decode_single(immediate_data) + if int(item_number) > len(evm.stack): + raise StackUnderflowError + data_to_duplicate = evm.stack[-item_number] + stack.push(evm.stack, data_to_duplicate) + + # PROGRAM COUNTER + evm.pc += Uint(2) + + +def swapn(evm: Evm) -> None: + """ + Swap the top stack item with the Nth stack item. + The value N is read from the immediate byte following the opcode and + decoded using the EIP-8024 index shifting rules. + + Parameters + ---------- + evm : + The current EVM frame. + + """ + # STACK + pass + + # GAS + charge_gas(evm, GasCosts.OPCODE_SWAPN) + + # OPERATION + immediate_data = U8( + buffer_read(evm.code, U256(evm.pc + Uint(1)), U256(1))[0] + ) + item_number = decode_single(immediate_data) + # SWAPN with decoded value n swaps top (position 1) with position (n+1) + if int(item_number) + 1 > len(evm.stack): + raise StackUnderflowError + # stack[-1] is top (position 1), stack[-(item_number+1)] is position (n+1) + evm.stack[-1], evm.stack[-(item_number + U8(1))] = ( + evm.stack[-(item_number + U8(1))], + evm.stack[-1], + ) + + # PROGRAM COUNTER + evm.pc += Uint(2) + + +def exchange(evm: Evm) -> None: + """ + Exchange the Nth stack item with the Mth stack item. + The values N and M are decoded from the immediate byte using the + EIP-8024 index shifting rules. + + Parameters + ---------- + evm : + The current EVM frame. + + """ + # STACK + pass + + # GAS + charge_gas(evm, GasCosts.OPCODE_EXCHANGE) + + # OPERATION + immediate_data = U8( + buffer_read(evm.code, U256(evm.pc + Uint(1)), U256(1))[0] + ) + n, m = decode_pair(immediate_data) + # EXCHANGE swaps position (n+1) with position (m+1) + depth = max(n, m) + U8(1) + if int(depth) > len(evm.stack): + raise StackUnderflowError + evm.stack[-(n + U8(1))], evm.stack[-(m + U8(1))] = ( + evm.stack[-(m + U8(1))], + evm.stack[-(n + U8(1))], + ) + + # PROGRAM COUNTER + evm.pc += Uint(2) diff --git a/src/ethereum/forks/monad_next/vm/instructions/system.py b/src/ethereum/forks/monad_next/vm/instructions/system.py index 7b8634c5d7e..99e31fc1a1b 100644 --- a/src/ethereum/forks/monad_next/vm/instructions/system.py +++ b/src/ethereum/forks/monad_next/vm/instructions/system.py @@ -35,6 +35,8 @@ from .. import ( Evm, Message, + emit_burn_log, + emit_transfer_log, incorporate_child_on_error, incorporate_child_on_success, ) @@ -584,6 +586,15 @@ def selfdestruct(evm: Evm) -> None: originator_balance, ) + # EIP-7708: Emit transfer or burn log for the beneficiary transfer + if ( + originator in evm.message.tx_env.state.created_accounts + and beneficiary == originator + ): + emit_burn_log(evm, originator, originator_balance) + elif beneficiary != originator: + emit_transfer_log(evm, originator, beneficiary, originator_balance) + # register account for deletion only if it was created # in the same transaction if originator in evm.message.tx_env.state.created_accounts: diff --git a/src/ethereum/forks/monad_next/vm/interpreter.py b/src/ethereum/forks/monad_next/vm/interpreter.py index 912ac3e42e8..d3a3a39d917 100644 --- a/src/ethereum/forks/monad_next/vm/interpreter.py +++ b/src/ethereum/forks/monad_next/vm/interpreter.py @@ -56,7 +56,7 @@ from ..vm.gas import GasCosts, charge_gas, page_index from ..vm.precompiled_contracts import MONAD_PRECOMPILE_ADDRESSES from ..vm.precompiled_contracts.mapping import PRE_COMPILED_CONTRACTS -from . import Evm, EvmMemory +from . import Evm, EvmMemory, emit_transfer_log from .exceptions import ( AddressCollision, ExceptionalHalt, @@ -402,6 +402,10 @@ def process_message(message: Message) -> Evm: message.current_target, message.value, ) + if message.caller != message.current_target: + emit_transfer_log( + evm, message.caller, message.current_target, message.value + ) try: if evm.message.code_address in PRE_COMPILED_CONTRACTS: diff --git a/src/ethereum/forks/monad_next/vm/runtime.py b/src/ethereum/forks/monad_next/vm/runtime.py index 0aa5ddd5e20..60fd42b52c9 100644 --- a/src/ethereum/forks/monad_next/vm/runtime.py +++ b/src/ethereum/forks/monad_next/vm/runtime.py @@ -28,6 +28,8 @@ def get_valid_jump_destinations(code: Bytes) -> Set[Uint]: * The jump destination should have the `JUMPDEST` opcode (0x5B). * The jump destination shouldn't be part of the data corresponding to `PUSH-N` opcodes. + * The jump destination shouldn't be part of the immediate byte + corresponding to `DUPN`, `SWAPN`, or `EXCHANGE` opcodes (EIP-8024). Note - Jump destinations are 0-indexed. @@ -63,6 +65,30 @@ def get_valid_jump_destinations(code: Bytes) -> Set[Uint]: # opcodes. push_data_size = current_opcode.value - Ops.PUSH1.value + 1 pc += Uint(push_data_size) + elif current_opcode in (Ops.DUPN, Ops.SWAPN): + # EIP-8024: DUPN/SWAPN invalid immediate range is + # 90 < x < 128, i.e. 0x5B (91) to 0x7F (127). + # Invalid immediates are not skipped so the byte + # remains at an instruction boundary. + if ( + pc + Uint(1) < ulen(code) + and 0x5B <= code[pc + Uint(1)] <= 0x7F + ): + pass + else: + pc += Uint(1) + elif current_opcode == Ops.EXCHANGE: + # EIP-8024: EXCHANGE invalid immediate range is + # 81 < x < 128, i.e. 0x52 (82) to 0x7F (127). + # Invalid immediates are not skipped so the byte + # remains at an instruction boundary. + if ( + pc + Uint(1) < ulen(code) + and 0x52 <= code[pc + Uint(1)] <= 0x7F + ): + pass + else: + pc += Uint(1) pc += Uint(1) diff --git a/src/ethereum/forks/monad_next/vm/stack.py b/src/ethereum/forks/monad_next/vm/stack.py index a87b0a47079..98ba815cb73 100644 --- a/src/ethereum/forks/monad_next/vm/stack.py +++ b/src/ethereum/forks/monad_next/vm/stack.py @@ -11,11 +11,84 @@ Implementation of the stack operators for the EVM. """ -from typing import List +from typing import List, Tuple -from ethereum_types.numeric import U256 +from ethereum_types.numeric import U8, U256 -from .exceptions import StackOverflowError, StackUnderflowError +from .exceptions import ( + InvalidParameter, + StackOverflowError, + StackUnderflowError, +) + + +def decode_single(x: U8) -> U8: + """ + Decode the immediate byte for DUPN/SWAPN to get the stack index. + + Return n with 17 <= n <= 235. + + Parameters + ---------- + x : int + The immediate byte value (0-90 or 128-255). + + Returns + ------- + int + The stack index n, where 17 <= n <= 235. + + Raises + ------ + InvalidParameter + If x is in the forbidden range (90 < x < 128 or x > 255). + + """ + if not (U8(0) <= x <= U8(90) or U8(128) <= x <= U8(255)): + raise InvalidParameter( + f"DUPN/SWAPN immediate byte {x} is out of range. " + "Valid range: 0 <= x <= 90 or 128 <= x <= 255" + ) + + return U8((int(x) + 145) % 256) + + +def decode_pair(x: U8) -> Tuple[U8, U8]: + """ + Decode the immediate byte for EXCHANGE to get two stack indices. + + Return (n, m) with 1 <= n <= 14 and n < m <= 30 - n. + + Parameters + ---------- + x : int + The immediate byte value (0-81 or 128-255). + + Returns + ------- + Tuple[int, int] + The two stack indices (n, m), where + 1 <= n <= 14 and n < m <= 30 - n. + + Raises + ------ + InvalidParameter + If x is in the forbidden range (81 < x < 128 or x > 255). + + """ + if not (U8(0) <= x <= U8(81) or U8(128) <= x <= U8(255)): + raise InvalidParameter( + f"EXCHANGE immediate byte {x} is in the forbidden " + "range 82 <= x <= 127\n" + "Valid range: 0 <= x <= 81 or 128 <= x <= 255" + ) + + k = U8(int(x) ^ 143) + q, r = divmod(k, U8(16)) + if q < r: + return q + U8(1), r + U8(1) + else: + return r + U8(1), U8(29) - q def pop(stack: List[U256]) -> U256: diff --git a/tests/amsterdam/eip7708_eth_transfer_logs/test_burn_logs.py b/tests/amsterdam/eip7708_eth_transfer_logs/test_burn_logs.py index f8f8c5eeeff..c67af24ee03 100644 --- a/tests/amsterdam/eip7708_eth_transfer_logs/test_burn_logs.py +++ b/tests/amsterdam/eip7708_eth_transfer_logs/test_burn_logs.py @@ -30,6 +30,7 @@ from execution_testing import ( Macros as Om, ) +from execution_testing.forks import MONAD_EIGHT from .spec import burn_log, ref_spec_7708, transfer_log @@ -39,6 +40,26 @@ pytestmark = pytest.mark.valid_from("EIP7708") +def _factory_with_runtime(factory_code: Bytecode) -> Bytecode: + """ + Append a minimal STOP-byte runtime deployment to a factory body. + + A factory created via a ``to=None`` transaction runs its body as + initcode; returning nothing deploys empty code. On Monad forks an + empty-code account that ends below the reserve balance is treated as + an EOA and reverts the whole transaction. Returning a single STOP + byte gives the factory non-empty runtime code so it is exempt from + the reserve-balance check. Inert on forks without a reserve balance. + """ + return factory_code + Op.MSTORE8(0, 0x00) + Op.RETURN(0, 1) + + +# Monad reserve balance (10 MON). Keeps a self-draining factory above the +# reserve in the gas-exact priority-fee test, where deploying runtime code +# would perturb the gas accounting. Inert on forks without a reserve balance. +MONAD_RESERVE_BALANCE = 10 * 10**18 + + def test_selfdestruct_to_self_pre_existing_no_log( state_test: StateTestFiller, env: Environment, @@ -431,6 +452,7 @@ def test_finalization_burn_logs( + Op.MSTORE(0, reverse_sorted[2]) + Op.CALL(gas=100_000, address=p3, args_offset=0, args_size=32) ) + factory_code = _factory_with_runtime(factory_code) factory_balance = 1000 + 2000 + 3000 pre.fund_address(factory_address, factory_balance) @@ -595,6 +617,7 @@ def test_finalization_burn_logs_multi_account_ordering( args_offset=0, args_size=32, ) + factory_code = _factory_with_runtime(factory_code) execution_logs = [ transfer_log(factory_address, addr, create_balances[i]) @@ -705,6 +728,7 @@ def test_finalization_burn_log_single_account_multiple_transfers( args_size=32, ), ) + factory_code = _factory_with_runtime(factory_code) execution_logs = [ transfer_log(factory_address, x, create_balance), @@ -837,7 +861,12 @@ def test_selfdestruct_finalization_after_priority_fee( Op.CALLDATALOAD(0), address_warm=True, account_new=False ).gas_cost(fork) - pre.fund_address(factory_address, contract_balance) + # Fund the factory above the reserve balance so it does not revert on + # Monad forks once it drains `contract_balance` into the created + # contract. Deploying runtime code instead would perturb this test's + # exact gas accounting, so funding is used here. Inert on forks without + # a reserve balance (the factory keeps the headroom, which is unasserted). + pre.fund_address(factory_address, contract_balance + MONAD_RESERVE_BALANCE) # prio fee calc gas_price = 10 @@ -872,7 +901,18 @@ def test_selfdestruct_finalization_after_priority_fee( gas_refunds, gas_used // 5, # max discount EIP-3529 ) - priority_fee = priority_fee_per_gas * (gas_used - discount) + + gas_limit = 500_000 + if fork.is_eip_enabled(8037): + gas_limit = 2_000_000 + + if fork >= MONAD_EIGHT: + # Monad charges the miner fee on the full gas limit (gas is not + # refunded to the sender), so the coinbase receives the priority + # fee on tx.gas rather than on the gas actually used. + priority_fee = priority_fee_per_gas * gas_limit + else: + priority_fee = priority_fee_per_gas * (gas_used - discount) # Finalization burn log proves coinbase received priority fee before log finalization_balance: int | None = funding_amount + priority_fee @@ -896,9 +936,6 @@ def test_selfdestruct_finalization_after_priority_fee( ) expected_logs.append(burn_log(created_address, finalization_balance)) - gas_limit = 500_000 - if fork.is_eip_enabled(8037): - gas_limit = 2_000_000 tx = Transaction( sender=sender, diff --git a/tests/amsterdam/eip7708_eth_transfer_logs/test_transfer_logs.py b/tests/amsterdam/eip7708_eth_transfer_logs/test_transfer_logs.py index 61c216406f8..9881c5f94d2 100644 --- a/tests/amsterdam/eip7708_eth_transfer_logs/test_transfer_logs.py +++ b/tests/amsterdam/eip7708_eth_transfer_logs/test_transfer_logs.py @@ -533,6 +533,7 @@ def test_failed_create_with_value_no_log( env: Environment, pre: Alloc, sender: EOA, + fork: Fork, initcode: Bytecode, ) -> None: """ @@ -547,11 +548,17 @@ def test_failed_create_with_value_no_log( ) + Op.SSTORE(0, Op.CREATE(1, 32 - initcode_len, initcode_len)) contract = pre.deploy_contract(contract_code, balance=1) + # INVALID initcode consumes all gas forwarded to the child CREATE + # frame, leaving the parent only the EIP-150 1/64 retained gas for + # the trailing SSTORE. Budget 64x that SSTORE's cost so the retained + # 1/64 covers it on forks with a heavier SSTORE schedule (MIP-8). + gas_limit = 100_000 + Op.SSTORE(new_value=0).gas_cost(fork) * 64 + tx = Transaction( sender=sender, to=contract, value=1, - gas_limit=500_000, + gas_limit=gas_limit, expected_receipt=TransactionReceipt( logs=[transfer_log(sender, contract, 1)] ),