Skip to content

Test Beacon Root Contract

Documentation for tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py.

Generate fixtures for these test cases for Cancun with:

Cancun only: 

fill -v tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py --fork=Cancun --evm-bin=/path/to/evm-tool-dev-version
For all forks up to and including Cancun: 
fill -v tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py --until=Cancun --evm-bin=/path/to/evm-tool-dev-version

abstract: Tests beacon block root for EIP-4788: Beacon block root in the EVM

Test the exposed beacon chain root in the EVM for [EIP-4788: Beacon block root in the EVM](https://eips.ethereum.org/EIPS/eip-4788)

note: Adding a new test

Add a function that is named `test_<test_name>` and takes at least the following arguments:

- state_test
- env
- pre
- tx
- post
- valid_call

The following arguments *need* to be parametrized or the test will not be generated:

-

All other `pytest.fixtures` can be parametrized to generate new combinations and test
cases.

test_beacon_root_contract_calls(state_test, env, pre, tx, post)

Tests the beacon root contract call using various call contexts: - CALL - DELEGATECALL - CALLCODE - STATICCALL for different call gas amounts: - exact gas (valid call) - extra gas (valid call) - insufficient gas (invalid call)

The expected result is that the contract call will be executed if the gas amount is met and return the correctparent_beacon_block_root. Otherwise the call will be invalid, and not be executed. This is highlighted within storage by storing the return value of each call context.

Source code in tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
@pytest.mark.parametrize(
    "call_gas, valid_call",
    [
        pytest.param(Spec.BEACON_ROOTS_CALL_GAS, True),
        pytest.param(Spec.BEACON_ROOTS_CALL_GAS + 1, True),
        pytest.param(
            Spec.BEACON_ROOTS_CALL_GAS - 1,
            False,
            marks=pytest.mark.xfail(reason="gas calculation is incorrect"),  # TODO
        ),
    ],
)
@pytest.mark.parametrize(
    "call_type,call_value,valid_input",
    [
        (Op.CALL, 1, True),
        (Op.CALL, 0, True),
        (Op.CALLCODE, 0, False),
        (Op.DELEGATECALL, 0, False),
        (Op.STATICCALL, 0, True),
    ],
)
@pytest.mark.valid_from("Cancun")
def test_beacon_root_contract_calls(
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Tests the beacon root contract call using various call contexts:
    - `CALL`
    - `DELEGATECALL`
    - `CALLCODE`
    - `STATICCALL`
    for different call gas amounts:
    - exact gas (valid call)
    - extra gas (valid call)
    - insufficient gas (invalid call)

    The expected result is that the contract call will be executed if the gas amount is met
    and return the correct`parent_beacon_block_root`. Otherwise the call will be invalid, and not
    be executed. This is highlighted within storage by storing the return value of each call
    context.
    """
    state_test(
        env=env,
        pre=pre,
        txs=[tx],
        post=post,
    )

test_beacon_root_contract_timestamps(state_test, env, pre, tx, post)

Tests the beacon root contract call across for various valid and invalid timestamps.

The expected result is that the contract call will return the correct parent_beacon_block_root for a valid input timestamp and return the zero'd 32 bytes value for an invalid input timestamp.

Source code in tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
@pytest.mark.parametrize(
    "timestamp, valid_input",
    [
        (0x0C, True),  # twelve
        (2**32, True),  # arbitrary
        (2**64 - 2, True),  # near-max
        (2**64 - 1, True),  # max
        # TODO: Update t8n to un marshal > 64-bit int
        # Exception: failed to evaluate: ERROR(10): failed un marshaling stdin
        # (2**64, False),  # overflow
        # Exception: failed to evaluate: ERROR(10): failed un marshaling stdin
        # (2**64 + 1, False),  # overflow+1
    ],
)
@pytest.mark.parametrize("auto_access_list", [False, True])
@pytest.mark.parametrize(
    "system_address_balance",
    [
        pytest.param(0, id="empty_system_address"),
        pytest.param(1, id="one_wei_system_address"),
        pytest.param(int(1e18), id="one_eth_system_address"),
    ],
)
@pytest.mark.valid_from("Cancun")
def test_beacon_root_contract_timestamps(
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Tests the beacon root contract call across for various valid and invalid timestamps.

    The expected result is that the contract call will return the correct
    `parent_beacon_block_root` for a valid input timestamp and return the zero'd 32 bytes value
    for an invalid input timestamp.
    """
    state_test(
        env=env,
        pre=pre,
        txs=[tx],
        post=post,
    )

test_calldata_lengths(state_test, env, pre, tx, post)

Tests the beacon root contract call using multiple invalid input lengths.

Source code in tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
@pytest.mark.parametrize(
    "tx_data",
    [
        pytest.param(bytes(), id="empty_calldata"),
        pytest.param(int.to_bytes(12, length=1, byteorder="big"), id="one_byte"),
        pytest.param(int.to_bytes(12, length=31, byteorder="big"), id="31_bytes"),
        pytest.param(int.to_bytes(12, length=33, byteorder="big"), id="33_bytes"),
        pytest.param(int.to_bytes(12, length=1024, byteorder="big"), id="1024_bytes"),
    ],
)
@pytest.mark.parametrize("valid_call,valid_input", [(False, False)])
@pytest.mark.parametrize("timestamp", [12])
@pytest.mark.valid_from("Cancun")
def test_calldata_lengths(
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Tests the beacon root contract call using multiple invalid input lengths.
    """
    state_test(
        env=env,
        pre=pre,
        txs=[tx],
        post=post,
    )

test_beacon_root_equal_to_timestamp(state_test, env, pre, tx, post)

Tests the beacon root contract call where the beacon root is equal to the timestamp.

The expected result is that the contract call will return the parent_beacon_block_root, as all timestamps used are valid.

Source code in tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py 
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
@pytest.mark.parametrize(
    "beacon_root, timestamp",
    [
        (12, 12),  # twelve
        (2**32, 2**32),  # arbitrary
        (2**64 - 2, 2**64 - 2),  # near-max
        (2**64 - 1, 2**64 - 1),  # max
    ],
    indirect=["beacon_root"],
)
@pytest.mark.parametrize("auto_access_list", [False, True])
@pytest.mark.valid_from("Cancun")
def test_beacon_root_equal_to_timestamp(
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Tests the beacon root contract call where the beacon root is equal to the timestamp.

    The expected result is that the contract call will return the `parent_beacon_block_root`,
    as all timestamps used are valid.
    """
    state_test(
        env=env,
        pre=pre,
        txs=[tx],
        post=post,
    )

test_tx_to_beacon_root_contract(state_test, env, pre, tx, post)

Tests the beacon root contract using a transaction with different types and data lengths.

Source code in tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py 
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
@pytest.mark.parametrize("auto_access_list", [False, True])
@pytest.mark.parametrize("call_beacon_root_contract", [True])
@pytest.mark.with_all_tx_types
@pytest.mark.valid_from("Cancun")
def test_tx_to_beacon_root_contract(
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Tests the beacon root contract using a transaction with different types and data lengths.
    """
    state_test(
        env=env,
        pre=pre,
        txs=[tx],
        post=post,
    )

test_invalid_beacon_root_calldata_value(state_test, env, pre, tx, post)

Tests the beacon root contract call using invalid input values: - zero calldata.

Contract should revert.

Source code in tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py 
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
@pytest.mark.parametrize(
    "tx_data",
    [
        pytest.param(int.to_bytes(0, length=32, byteorder="big"), id="zero_calldata"),
    ],
)
@pytest.mark.parametrize("valid_call,valid_input", [(False, False)])
@pytest.mark.parametrize("timestamp", [12])
@pytest.mark.valid_from("Cancun")
def test_invalid_beacon_root_calldata_value(
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Tests the beacon root contract call using invalid input values:
    - zero calldata.

    Contract should revert.
    """
    state_test(
        env=env,
        pre=pre,
        txs=[tx],
        post=post,
    )

test_beacon_root_selfdestruct(state_test, env, pre, tx, post)

Tests that self destructing the beacon root address transfers actors balance correctly.

Source code in tests/cancun/eip4788_beacon_root/test_beacon_root_contract.py 
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
@pytest.mark.parametrize("timestamp", [12])
@pytest.mark.valid_from("Cancun")
def test_beacon_root_selfdestruct(
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Tests that self destructing the beacon root address transfers actors balance correctly.
    """
    # self destruct actor
    pre[to_address(0x1337)] = Account(
        code=Op.SELFDESTRUCT(Spec.BEACON_ROOTS_ADDRESS),
        balance=0xBA1,
    )
    # self destruct caller
    pre[to_address(0xCC)] = Account(
        code=Op.CALL(100000, Op.PUSH20(to_address(0x1337)), 0, 0, 0, 0, 0)
        + Op.SSTORE(0, Op.BALANCE(Spec.BEACON_ROOTS_ADDRESS)),
    )
    post[to_address(0xCC)] = Account(
        storage=Storage({0: 0xBA1}),
    )
    state_test(
        env=env,
        pre=pre,
        txs=[tx, Transaction(nonce=1, to=to_address(0xCC), gas_limit=100000, gas_price=10)],
        post=post,
    )