From b5b871b54942712ef80574f3849bb940ed7ec613 Mon Sep 17 00:00:00 2001 From: pdobacz <5735525+pdobacz@users.noreply.github.com> Date: Tue, 1 Oct 2024 19:45:05 +0200 Subject: [PATCH] new(tests): EIP-7069 and EIP-7620 - failures and context vars (#836) * new(tests): EOF - EIP-7069: callee fails tests * new(tests): EOF - EIP-7069: context variables * new(tests): EOF - EIP-7620: context variables * new(tests): EOF - EIP-7069: call precompiles * Apply suggestions from code review Co-authored-by: Mario Vega * new(tests): EOF - EIP-7698: context variables --------- Co-authored-by: Mario Vega --- .../eip7069_extcall/test_calls.py | 202 +++++++++++++++--- .../eip7620_eof_create/test_eofcreate.py | 80 +++++++ .../eip7698_eof_creation_tx/__init__.py | 3 + .../eip7698_eof_creation_tx/helpers.py | 16 ++ .../test_eof_creation_tx.py | 79 +++++++ tests/prague/eip7692_eof_v1/eof_tracker.md | 12 +- whitelist.txt | 1 + 7 files changed, 357 insertions(+), 36 deletions(-) create mode 100644 tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/__init__.py create mode 100644 tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/helpers.py create mode 100644 tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/test_eof_creation_tx.py diff --git a/tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py b/tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py index f006ff40ad..e813e099f7 100644 --- a/tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py +++ b/tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py @@ -17,6 +17,8 @@ ) from ethereum_test_tools.eof.v1 import Container, Section from ethereum_test_tools.vm.opcode import Opcodes as Op +from ethereum_test_vm.bytecode import Bytecode +from ethereum_test_vm.evm_types import EVMCodeType from .. import EOF_FORK_NAME from .spec import ( @@ -93,7 +95,6 @@ def test_legacy_calls_eof_sstore( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = Storage( @@ -166,7 +167,6 @@ def test_legacy_calls_eof_mstore( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = { @@ -222,7 +222,6 @@ def test_eof_calls_eof_sstore( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = Storage( @@ -296,7 +295,6 @@ def test_eof_calls_eof_mstore( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = { @@ -320,6 +318,69 @@ def test_eof_calls_eof_mstore( ) +identity = Address(0x04) +# `blake2f`` is chosen for the test because it fails unless args_size == 213, which is what we are +# interested in. +blake2f = Address(0x09) + + +@pytest.mark.parametrize( + ["opcode", "precompile", "expected_result"], + [ + pytest.param(Op.EXTCALL, identity, EXTCALL_SUCCESS, id="extcall_success"), + pytest.param(Op.EXTDELEGATECALL, identity, EXTCALL_REVERT, id="extdelegatecall_blocked1"), + pytest.param(Op.EXTSTATICCALL, identity, EXTCALL_SUCCESS, id="extstaticcall_success"), + pytest.param(Op.EXTCALL, blake2f, EXTCALL_FAILURE, id="extcall_failure"), + pytest.param(Op.EXTDELEGATECALL, blake2f, EXTCALL_REVERT, id="extdelegatecall_blocked2"), + pytest.param(Op.EXTSTATICCALL, blake2f, EXTCALL_FAILURE, id="extstaticcall_failure"), + ], +) +def test_eof_calls_precompile( + state_test: StateTestFiller, + pre: Alloc, + sender: EOA, + opcode: Op, + precompile: Address, + expected_result: int, +): + """Test EOF contracts calling precompiles""" + env = Environment() + + caller_contract = Container.Code( + Op.MSTORE(0, value_returndata_magic) + + Op.SSTORE(slot_call_result, opcode(address=precompile, args_offset=0, args_size=32)) + + Op.SSTORE(slot_returndatasize, Op.RETURNDATASIZE) + + Op.SSTORE(slot_returndata, Op.RETURNDATALOAD(0)) + + Op.SSTORE(slot_code_worked, value_code_worked) + + Op.STOP, + ) + calling_contract_address = pre.deploy_contract(caller_contract) + + tx = Transaction( + sender=sender, + to=Address(calling_contract_address), + gas_limit=5000000, + ) + + calling_storage = { + slot_code_worked: value_code_worked, + slot_call_result: expected_result, + slot_returndatasize: 32 if expected_result == EXTCALL_SUCCESS else 0, + slot_returndata: value_returndata_magic if expected_result == EXTCALL_SUCCESS else 0, + } + + post = { + calling_contract_address: Account(storage=calling_storage), + } + + state_test( + env=env, + pre=pre, + post=post, + tx=tx, + ) + + @pytest.mark.parametrize( "opcode", [ @@ -354,7 +415,6 @@ def test_eof_calls_legacy_sstore( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = { @@ -422,7 +482,6 @@ def test_eof_calls_legacy_mstore( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = { @@ -461,30 +520,106 @@ def test_eof_calls_legacy_mstore( ], ) @pytest.mark.parametrize( - "destination_opcode", - [Op.REVERT, Op.INVALID], + ["destination_code", "expected_result"], + [ + pytest.param(Op.REVERT(0, 0), EXTCALL_REVERT, id="legacy_revert"), + pytest.param(Op.INVALID, EXTCALL_FAILURE, id="legacy_invalid"), + pytest.param(Op.SHA3(0, 2**255), EXTCALL_FAILURE, id="legacy_oog"), + pytest.param(Op.RETURNDATACOPY(0, 1, 2), EXTCALL_FAILURE, id="legacy_oob_returndata"), + pytest.param(Container.Code(Op.REVERT(0, 0)), EXTCALL_REVERT, id="eof_revert"), + pytest.param(Container.Code(Op.INVALID), EXTCALL_FAILURE, id="eof_invalid"), + pytest.param( + Container.Code(Op.SHA3(0, 2**255) + Op.STOP), EXTCALL_FAILURE, id="eof_oog" + ), + ], +) +def test_callee_fails( + state_test: StateTestFiller, + pre: Alloc, + sender: EOA, + opcode: Op, + destination_code: Bytecode | Container, + expected_result: int, +): + """Test EOF contracts calling contracts that fail for various reasons""" + env = Environment() + + destination_contract_address = pre.deploy_contract(destination_code) + + caller_contract = Container.Code( + Op.SSTORE(slot_code_worked, value_code_worked) + + Op.SSTORE(slot_call_result, opcode(address=destination_contract_address)) + + Op.STOP, + ) + calling_contract_address = pre.deploy_contract(caller_contract) + + tx = Transaction( + sender=sender, + to=Address(calling_contract_address), + gas_limit=4000000, + ) + + calling_storage = { + slot_code_worked: value_code_worked, + slot_call_result: EXTCALL_REVERT + if opcode == Op.EXTDELEGATECALL and not isinstance(destination_code, Container) + else expected_result, + } + + post = { + calling_contract_address: Account(storage=calling_storage), + destination_contract_address: Account(storage={}), + } + + state_test( + env=env, + pre=pre, + post=post, + tx=tx, + ) + + +@pytest.mark.parametrize( + ["opcode", "destination_code", "expected_result"], + [ + pytest.param(Op.EXTCALL, Op.ADDRESS, "destination", id="extcall_address"), + pytest.param(Op.EXTDELEGATECALL, Op.ADDRESS, "caller", id="extdelegatecall_address"), + pytest.param(Op.EXTSTATICCALL, Op.ADDRESS, "destination", id="extstaticcall_address"), + pytest.param(Op.EXTCALL, Op.CALLER, "caller", id="extcall_caller"), + pytest.param(Op.EXTDELEGATECALL, Op.CALLER, "sender", id="extdelegatecall_caller"), + pytest.param(Op.EXTSTATICCALL, Op.CALLER, "caller", id="extstaticcall_caller"), + pytest.param(Op.EXTCALL, Op.CALLVALUE, 0, id="extcall_call_value"), + pytest.param( + Op.EXTDELEGATECALL, Op.CALLVALUE, "tx_value", id="extdelegatecall_call_value" + ), + pytest.param(Op.EXTSTATICCALL, Op.CALLVALUE, 0, id="extstaticcall_call_value"), + pytest.param(Op.EXTCALL, Op.ORIGIN, "sender", id="extcall_origin"), + pytest.param(Op.EXTDELEGATECALL, Op.ORIGIN, "sender", id="extdelegatecall_origin"), + pytest.param(Op.EXTSTATICCALL, Op.ORIGIN, "sender", id="extstaticcall_origin"), + ], ) -@pytest.mark.parametrize("destination_is_eof", [True, False]) -def test_eof_calls_revert_abort( +@pytest.mark.with_all_evm_code_types +def test_callee_context( state_test: StateTestFiller, pre: Alloc, sender: EOA, opcode: Op, - destination_opcode: Op, - destination_is_eof: bool, + destination_code: Bytecode, + expected_result: str | int, + evm_code_type: EVMCodeType, ): - """Test EOF contracts calling contracts that revert or abort""" + """Test EOF calls' callee context instructions""" env = Environment() + tx_value = 0x1123 destination_contract_address = pre.deploy_contract( - Container.Code(destination_opcode(offset=0, size=0)) - if destination_is_eof - else destination_opcode(offset=0, size=0) + Op.MSTORE(0, destination_code) + Op.RETURN(0, 32) ) caller_contract = Container.Code( - Op.SSTORE(slot_call_result, opcode(address=destination_contract_address)) - + Op.SSTORE(slot_code_worked, value_code_worked) + Op.SSTORE(slot_code_worked, value_code_worked) + + opcode(address=destination_contract_address) + + Op.SSTORE(slot_returndata, Op.RETURNDATALOAD(0)) + Op.STOP, ) calling_contract_address = pre.deploy_contract(caller_contract) @@ -492,16 +627,29 @@ def test_eof_calls_revert_abort( tx = Transaction( sender=sender, to=Address(calling_contract_address), - gas_limit=50000000, - data="", + gas_limit=100000, + value=tx_value, ) + expected_bytes: Address | int + if expected_result == "destination": + expected_bytes = destination_contract_address + elif expected_result == "caller": + expected_bytes = calling_contract_address + elif expected_result == "sender": + expected_bytes = sender + elif expected_result == "tx_value": + expected_bytes = tx_value + elif isinstance(expected_result, int): + expected_bytes = expected_result + else: + raise TypeError("Unexpected expected_result", expected_result) + calling_storage = { slot_code_worked: value_code_worked, - slot_call_result: EXTCALL_REVERT - if destination_opcode == Op.REVERT - or (opcode == Op.EXTDELEGATECALL and not destination_is_eof) - else EXTCALL_FAILURE, + slot_returndata: 0 + if (opcode == Op.EXTDELEGATECALL and evm_code_type == EVMCodeType.LEGACY) + else expected_bytes, } post = { @@ -547,7 +695,6 @@ def test_eof_calls_eof_then_fails( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) post = { @@ -638,7 +785,6 @@ def test_eof_calls_clear_return_buffer( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = { @@ -699,7 +845,6 @@ def test_eof_calls_static_flag_with_value( sender=sender, to=Address(calling_contract_address), gas_limit=5_000_000, - data="", ) calling_storage = { @@ -797,7 +942,6 @@ def test_eof_calls_min_callee_gas( sender=sender, to=Address(calling_contract_address), gas_limit=no_oog_gas + extra_gas_limit, - data="", ) calling_storage = { @@ -844,7 +988,6 @@ def test_eof_calls_with_value( sender=sender, to=Address(calling_contract_address), gas_limit=50000000, - data="", ) calling_storage = { @@ -941,7 +1084,6 @@ def test_eof_calls_msg_depth( sender=sender, to=Address(calling_contract_address), gas_limit=gas_limit, - data="", ) calling_storage = { diff --git a/tests/prague/eip7692_eof_v1/eip7620_eof_create/test_eofcreate.py b/tests/prague/eip7692_eof_v1/eip7620_eof_create/test_eofcreate.py index cebc9e215e..67d1eec1b6 100644 --- a/tests/prague/eip7692_eof_v1/eip7620_eof_create/test_eofcreate.py +++ b/tests/prague/eip7692_eof_v1/eip7620_eof_create/test_eofcreate.py @@ -4,6 +4,7 @@ import pytest +from ethereum_test_base_types.base_types import Address from ethereum_test_exceptions import EOFException from ethereum_test_specs import EOFTestFiller from ethereum_test_tools import ( @@ -16,6 +17,7 @@ ) from ethereum_test_tools.eof.v1 import Container, Section from ethereum_test_tools.vm.opcode import Opcodes as Op +from ethereum_test_vm.bytecode import Bytecode from .. import EOF_FORK_NAME from ..eip7069_extcall.spec import EXTCALL_SUCCESS @@ -590,3 +592,81 @@ def test_eofcreate_invalid_index( ), expect_exception=EOFException.INVALID_CONTAINER_SECTION_INDEX, ) + + +@pytest.mark.parametrize( + ["destination_code", "expected_result"], + [ + pytest.param(Op.ADDRESS, "destination"), + pytest.param(Op.CALLER, "caller"), + pytest.param(Op.CALLVALUE, "eofcreate_value"), + pytest.param(Op.ORIGIN, "sender"), + ], +) +def test_eofcreate_context( + state_test: StateTestFiller, + pre: Alloc, + destination_code: Bytecode, + expected_result: str, +): + """Test EOFCREATE's initcode context instructions""" + env = Environment() + sender = pre.fund_eoa() + value = 0x1123 + eofcreate_value = 0x13 + + initcode = Container( + sections=[ + Section.Code( + Op.SSTORE(slot_call_result, destination_code) + Op.RETURNCONTRACT[0](0, 0) + ), + Section.Container(smallest_runtime_subcontainer), + ] + ) + + caller_contract = Container( + sections=[ + Section.Code( + Op.SSTORE(slot_code_worked, value_code_worked) + + Op.EOFCREATE[0](eofcreate_value, 0, 0, 0) + + Op.STOP + ), + Section.Container(initcode), + ] + ) + calling_contract_address = pre.deploy_contract(caller_contract) + + destination_contract_address = compute_eofcreate_address(calling_contract_address, 0, initcode) + + tx = Transaction(sender=sender, to=calling_contract_address, gas_limit=1000000, value=value) + + expected_bytes: Address | int + if expected_result == "destination": + expected_bytes = destination_contract_address + elif expected_result == "caller": + expected_bytes = calling_contract_address + elif expected_result == "sender": + expected_bytes = sender + elif expected_result == "eofcreate_value": + expected_bytes = eofcreate_value + else: + raise TypeError("Unexpected expected_result", expected_result) + + calling_storage = { + slot_code_worked: value_code_worked, + } + destination_contract_storage = { + slot_call_result: expected_bytes, + } + + post = { + calling_contract_address: Account(storage=calling_storage), + destination_contract_address: Account(storage=destination_contract_storage), + } + + state_test( + env=env, + pre=pre, + post=post, + tx=tx, + ) diff --git a/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/__init__.py b/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/__init__.py new file mode 100644 index 0000000000..c3eb3d76d7 --- /dev/null +++ b/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/__init__.py @@ -0,0 +1,3 @@ +""" +EOF creation transaction (empty `to`) tests +""" diff --git a/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/helpers.py b/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/helpers.py new file mode 100644 index 0000000000..91769db923 --- /dev/null +++ b/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/helpers.py @@ -0,0 +1,16 @@ +""" +A collection of contracts used in 7698 EOF tests +""" +import itertools + +from ethereum_test_tools import Opcodes as Op +from ethereum_test_tools.eof.v1 import Container + +"""Storage addresses for common testing fields""" +_slot = itertools.count() +next(_slot) # don't use slot 0 +slot_call_result = next(_slot) + +slot_last_slot = next(_slot) + +smallest_runtime_subcontainer = Container.Code(code=Op.STOP, name="Runtime Subcontainer") diff --git a/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/test_eof_creation_tx.py b/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/test_eof_creation_tx.py new file mode 100644 index 0000000000..f82b5f4f3d --- /dev/null +++ b/tests/prague/eip7692_eof_v1/eip7698_eof_creation_tx/test_eof_creation_tx.py @@ -0,0 +1,79 @@ +""" +Test execution of EOF creation txs +""" + +import pytest + +from ethereum_test_base_types.base_types import Address +from ethereum_test_tools import Account, Alloc, Environment, StateTestFiller, Transaction +from ethereum_test_tools.eof.v1 import Container, Section +from ethereum_test_tools.vm.opcode import Opcodes as Op +from ethereum_test_types.helpers import compute_create_address +from ethereum_test_vm.bytecode import Bytecode + +from .. import EOF_FORK_NAME +from .helpers import slot_call_result, smallest_runtime_subcontainer + +REFERENCE_SPEC_GIT_PATH = "EIPS/eip-7698.md" +REFERENCE_SPEC_VERSION = "ff544c14889aeb84be214546a09f410a67b919be" + +pytestmark = pytest.mark.valid_from(EOF_FORK_NAME) + + +@pytest.mark.parametrize( + ["destination_code", "expected_result"], + [ + pytest.param(Op.ADDRESS, "destination"), + pytest.param(Op.CALLER, "sender"), + pytest.param(Op.CALLVALUE, "value"), + pytest.param(Op.ORIGIN, "sender"), + ], +) +def test_eof_creation_tx_context( + state_test: StateTestFiller, + pre: Alloc, + destination_code: Bytecode, + expected_result: str, +): + """Test EOF creation txs' initcode context instructions""" + env = Environment() + sender = pre.fund_eoa() + value = 0x1123 + + initcode = Container( + sections=[ + Section.Code( + Op.SSTORE(slot_call_result, destination_code) + Op.RETURNCONTRACT[0](0, 0) + ), + Section.Container(smallest_runtime_subcontainer), + ] + ) + + destination_contract_address = compute_create_address(address=sender, nonce=sender.nonce) + + tx = Transaction(sender=sender, to=None, gas_limit=100000, value=value, input=initcode) + + expected_bytes: Address | int + if expected_result == "destination": + expected_bytes = destination_contract_address + elif expected_result == "sender": + expected_bytes = sender + elif expected_result == "value": + expected_bytes = value + else: + raise TypeError("Unexpected expected_result", expected_result) + + destination_contract_storage = { + slot_call_result: expected_bytes, + } + + post = { + destination_contract_address: Account(storage=destination_contract_storage), + } + + state_test( + env=env, + pre=pre, + post=post, + tx=tx, + ) diff --git a/tests/prague/eip7692_eof_v1/eof_tracker.md b/tests/prague/eip7692_eof_v1/eof_tracker.md index b0c100b8a3..8d4d4375ee 100644 --- a/tests/prague/eip7692_eof_v1/eof_tracker.md +++ b/tests/prague/eip7692_eof_v1/eof_tracker.md @@ -403,17 +403,17 @@ - [x] OOG after EXTCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_eof_then_fails`](./eip7069_extcall/test_calls/test_eof_calls_eof_then_fails.md)) - [x] OOG after EXTDELEGATECALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_eof_then_fails`](./eip7069_extcall/test_calls/test_eof_calls_eof_then_fails.md)) - [x] OOG after EXTSTATICCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_eof_then_fails`](./eip7069_extcall/test_calls/test_eof_calls_eof_then_fails.md)) -- [x] REVERT inside EXTCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_revert_abort`](./eip7069_extcall/test_calls/test_eof_calls_revert_abort.md)) -- [x] REVERT inside EXTDELEGATECALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_revert_abort`](./eip7069_extcall/test_calls/test_eof_calls_revert_abort.md)) -- [x] REVERT inside EXTSTATICCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_revert_abort`](./eip7069_extcall/test_calls/test_eof_calls_revert_abort.md)) +- [x] REVERT inside EXTCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_callee_fails`](./eip7069_extcall/test_calls/test_callee_fails.md)) +- [x] REVERT inside EXTDELEGATECALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_callee_fails`](./eip7069_extcall/test_calls/test_callee_fails.md)) +- [x] REVERT inside EXTSTATICCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_callee_fails`](./eip7069_extcall/test_calls/test_callee_fails.md)) - [x] EXTCALL with input (`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calldata.py`) - [x] EXTDELEGATECALL with input (`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calldata.py`) - [x] EXTSTATICCALL with input (`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calldata.py`) - [x] EXTCALL with just enough gas for MIN_RETAINED_GAS and MIN_CALLEE_GAS ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_min_callee_gas`](./eip7069_extcall/test_calls/test_eof_calls_min_callee_gas.md)) - [x] EXTCALL with not enough gas for MIN_CALLEE_GAS ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_min_callee_gas`](./eip7069_extcall/test_calls/test_eof_calls_min_callee_gas.md)) -- [ ] ADDRESS and CALLER inside EXTCALL (evmone-tests: state_tests/state_transition/eof_calls/extcall_recipient_and_code_address.json) -- [ ] ADDRESS and CALLER inside EXTDELEGATECALL (evmone-tests: state_tests/state_transition/eof_calls/extdelegatecall_recipient_and_code_address.json) -- [ ] ADDRESS and CALLER inside EXTSTATICCALL (evmone-tests: state_tests/state_transition/eof_calls/extstaticcall_recipient_and_code_address.json) +- [x] ADDRESS and CALLER inside EXTCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_callee_context`](./eip7069_extcall/test_calls/test_callee_context.md)) +- [x] ADDRESS and CALLER inside EXTDELEGATECALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_callee_context`](./eip7069_extcall/test_calls/test_callee_context.md)) +- [x] ADDRESS and CALLER inside EXTSTATICCALL ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_callee_context`](./eip7069_extcall/test_calls/test_callee_context.md)) - [ ] Refund inside EXTCALL is applied after the transaction (evmone-tests: state_tests/state_transition/eof_calls/extcall_gas_refund_propagation.json) - [ ] Refund inside EXTDELEGATECALL is applied after the transaction (evmone-tests: state_tests/state_transition/eof_calls/extdelegatecall_gas_refund_propagation.json) - [x] EXTSTATICCALL from EOF to non-pure legacy contract failing ([`./tests/prague/eip7692_eof_v1/eip7069_extcall/test_calls.py::test_eof_calls_legacy_sstore`](./eip7069_extcall/test_calls/test_eof_calls_legacy_sstore.md)) diff --git a/whitelist.txt b/whitelist.txt index e39700260b..d0494bea0e 100644 --- a/whitelist.txt +++ b/whitelist.txt @@ -29,6 +29,7 @@ bidict big0 big1 bigint +blake2f blobgasfee blockchain BlockchainFixtures