ethereum.forks.berlin.vm.instructions.system

Ethereum Virtual Machine (EVM) System Instructions.

.. contents:: Table of Contents :backlinks: none :local:

Introduction

Implementations of the EVM system related instructions.

generic_create

Core logic used by the CREATE* family of opcodes.

def generic_create(​evm: Evm, ​​endowment: U256, ​​contract_address: Address, ​​memory_start_position: U256, ​​memory_size: U256​) -> None:
68
    """
69
    Core logic used by the `CREATE*` family of opcodes.
70
    """
71
    # This import causes a circular import error
72
    # if it's not moved inside this method
73
    from ...vm.interpreter import STACK_DEPTH_LIMIT, process_create_message
74
75
    call_data = memory_read_bytes(
76
        evm.memory, memory_start_position, memory_size
77
    )
78
79
    create_message_gas = max_message_call_gas(Uint(evm.gas_left))
80
    evm.gas_left -= create_message_gas
81
    if evm.message.is_static:
82
        raise WriteInStaticContext
83
    evm.return_data = b""
84
85
    sender_address = evm.message.current_target
86
    sender = get_account(evm.message.block_env.state, sender_address)
87
88
    if (
89
        sender.balance < endowment
90
        or sender.nonce == Uint(2**64 - 1)
91
        or evm.message.depth + Uint(1) > STACK_DEPTH_LIMIT
92
    ):
93
        evm.gas_left += create_message_gas
94
        push(evm.stack, U256(0))
95
        return
96
97
    evm.accessed_addresses.add(contract_address)
98
99
    if account_has_code_or_nonce(
100
        evm.message.block_env.state, contract_address
101
    ) or account_has_storage(evm.message.block_env.state, contract_address):
102
        increment_nonce(
103
            evm.message.block_env.state, evm.message.current_target
104
        )
105
        push(evm.stack, U256(0))
106
        return
107
108
    increment_nonce(evm.message.block_env.state, evm.message.current_target)
109
110
    child_message = Message(
111
        block_env=evm.message.block_env,
112
        tx_env=evm.message.tx_env,
113
        caller=evm.message.current_target,
114
        target=Bytes0(),
115
        gas=create_message_gas,
116
        value=endowment,
117
        data=b"",
118
        code=call_data,
119
        current_target=contract_address,
120
        depth=evm.message.depth + Uint(1),
121
        code_address=None,
122
        should_transfer_value=True,
123
        is_static=False,
124
        accessed_addresses=evm.accessed_addresses.copy(),
125
        accessed_storage_keys=evm.accessed_storage_keys.copy(),
126
        parent_evm=evm,
127
    )
128
    child_evm = process_create_message(child_message)
129
130
    if child_evm.error:
131
        incorporate_child_on_error(evm, child_evm)
132
        evm.return_data = child_evm.output
133
        push(evm.stack, U256(0))
134
    else:
135
        incorporate_child_on_success(evm, child_evm)
136
        evm.return_data = b""
137
        push(evm.stack, U256.from_be_bytes(child_evm.message.current_target))

create

Creates a new account with associated code.

Parameters

evm : The current EVM frame.

def create(​evm: Evm​) -> None:
141
    """
142
    Creates a new account with associated code.
143
144
    Parameters
145
    ----------
146
    evm :
147
        The current EVM frame.
148
149
    """
150
    # STACK
151
    endowment = pop(evm.stack)
152
    memory_start_position = pop(evm.stack)
153
    memory_size = pop(evm.stack)
154
155
    # GAS
156
    extend_memory = calculate_gas_extend_memory(
157
        evm.memory, [(memory_start_position, memory_size)]
158
    )
159
160
    charge_gas(evm, GAS_CREATE + extend_memory.cost)
161
162
    # OPERATION
163
    evm.memory += b"\x00" * extend_memory.expand_by
164
    contract_address = compute_contract_address(
165
        evm.message.current_target,
166
        get_account(
167
            evm.message.block_env.state, evm.message.current_target
168
        ).nonce,
169
    )
170
171
    generic_create(
172
        evm, endowment, contract_address, memory_start_position, memory_size
173
    )
174
175
    # PROGRAM COUNTER
176
    evm.pc += Uint(1)

create2

Creates a new account with associated code.

It's similar to CREATE opcode except that the address of new account depends on the init_code instead of the nonce of sender.

Parameters

evm : The current EVM frame.

def create2(​evm: Evm​) -> None:
180
    """
181
    Creates a new account with associated code.
182
183
    It's similar to CREATE opcode except that the address of new account
184
    depends on the init_code instead of the nonce of sender.
185
186
    Parameters
187
    ----------
188
    evm :
189
        The current EVM frame.
190
191
    """
192
    # STACK
193
    endowment = pop(evm.stack)
194
    memory_start_position = pop(evm.stack)
195
    memory_size = pop(evm.stack)
196
    salt = pop(evm.stack).to_be_bytes32()
197
198
    # GAS
199
    extend_memory = calculate_gas_extend_memory(
200
        evm.memory, [(memory_start_position, memory_size)]
201
    )
202
    call_data_words = ceil32(Uint(memory_size)) // Uint(32)
203
    charge_gas(
204
        evm,
205
        GAS_CREATE + GAS_KECCAK256_WORD * call_data_words + extend_memory.cost,
206
    )
207
208
    # OPERATION
209
    evm.memory += b"\x00" * extend_memory.expand_by
210
    contract_address = compute_create2_contract_address(
211
        evm.message.current_target,
212
        salt,
213
        memory_read_bytes(evm.memory, memory_start_position, memory_size),
214
    )
215
216
    generic_create(
217
        evm, endowment, contract_address, memory_start_position, memory_size
218
    )
219
220
    # PROGRAM COUNTER
221
    evm.pc += Uint(1)

return_

Halts execution returning output data.

Parameters

evm : The current EVM frame.

def return_(​evm: Evm​) -> None:
225
    """
226
    Halts execution returning output data.
227
228
    Parameters
229
    ----------
230
    evm :
231
        The current EVM frame.
232
233
    """
234
    # STACK
235
    memory_start_position = pop(evm.stack)
236
    memory_size = pop(evm.stack)
237
238
    # GAS
239
    extend_memory = calculate_gas_extend_memory(
240
        evm.memory, [(memory_start_position, memory_size)]
241
    )
242
243
    charge_gas(evm, GAS_ZERO + extend_memory.cost)
244
245
    # OPERATION
246
    evm.memory += b"\x00" * extend_memory.expand_by
247
    evm.output = memory_read_bytes(
248
        evm.memory, memory_start_position, memory_size
249
    )
250
251
    evm.running = False
252
253
    # PROGRAM COUNTER
254
    pass

generic_call

Perform the core logic of the CALL* family of opcodes.

def generic_call(​evm: Evm, ​​gas: Uint, ​​value: U256, ​​caller: Address, ​​to: Address, ​​code_address: Address, ​​should_transfer_value: bool, ​​is_staticcall: bool, ​​memory_input_start_position: U256, ​​memory_input_size: U256, ​​memory_output_start_position: U256, ​​memory_output_size: U256​) -> None:
271
    """
272
    Perform the core logic of the `CALL*` family of opcodes.
273
    """
274
    from ...vm.interpreter import STACK_DEPTH_LIMIT, process_message
275
276
    evm.return_data = b""
277
278
    if evm.message.depth + Uint(1) > STACK_DEPTH_LIMIT:
279
        evm.gas_left += gas
280
        push(evm.stack, U256(0))
281
        return
282
283
    call_data = memory_read_bytes(
284
        evm.memory, memory_input_start_position, memory_input_size
285
    )
286
    code = get_account(evm.message.block_env.state, code_address).code
287
    child_message = Message(
288
        block_env=evm.message.block_env,
289
        tx_env=evm.message.tx_env,
290
        caller=caller,
291
        target=to,
292
        gas=gas,
293
        value=value,
294
        data=call_data,
295
        code=code,
296
        current_target=to,
297
        depth=evm.message.depth + Uint(1),
298
        code_address=code_address,
299
        should_transfer_value=should_transfer_value,
300
        is_static=True if is_staticcall else evm.message.is_static,
301
        accessed_addresses=evm.accessed_addresses.copy(),
302
        accessed_storage_keys=evm.accessed_storage_keys.copy(),
303
        parent_evm=evm,
304
    )
305
    child_evm = process_message(child_message)
306
307
    if child_evm.error:
308
        incorporate_child_on_error(evm, child_evm)
309
        evm.return_data = child_evm.output
310
        push(evm.stack, U256(0))
311
    else:
312
        incorporate_child_on_success(evm, child_evm)
313
        evm.return_data = child_evm.output
314
        push(evm.stack, U256(1))
315
316
    actual_output_size = min(memory_output_size, U256(len(child_evm.output)))
317
    memory_write(
318
        evm.memory,
319
        memory_output_start_position,
320
        child_evm.output[:actual_output_size],
321
    )

call

Message-call into an account.

Parameters

evm : The current EVM frame.

def call(​evm: Evm​) -> None:
325
    """
326
    Message-call into an account.
327
328
    Parameters
329
    ----------
330
    evm :
331
        The current EVM frame.
332
333
    """
334
    # STACK
335
    gas = Uint(pop(evm.stack))
336
    to = to_address_masked(pop(evm.stack))
337
    value = pop(evm.stack)
338
    memory_input_start_position = pop(evm.stack)
339
    memory_input_size = pop(evm.stack)
340
    memory_output_start_position = pop(evm.stack)
341
    memory_output_size = pop(evm.stack)
342
343
    # GAS
344
    extend_memory = calculate_gas_extend_memory(
345
        evm.memory,
346
        [
347
            (memory_input_start_position, memory_input_size),
348
            (memory_output_start_position, memory_output_size),
349
        ],
350
    )
351
352
    if to in evm.accessed_addresses:
353
        access_gas_cost = GAS_WARM_ACCESS
354
    else:
355
        evm.accessed_addresses.add(to)
356
        access_gas_cost = GAS_COLD_ACCOUNT_ACCESS
357
358
    code_address = to
359
360
    create_gas_cost = GAS_NEW_ACCOUNT
361
    if value == 0 or is_account_alive(evm.message.block_env.state, to):
362
        create_gas_cost = Uint(0)
363
    transfer_gas_cost = Uint(0) if value == 0 else GAS_CALL_VALUE
364
    message_call_gas = calculate_message_call_gas(
365
        value,
366
        gas,
367
        Uint(evm.gas_left),
368
        extend_memory.cost,
369
        access_gas_cost + create_gas_cost + transfer_gas_cost,
370
    )
371
    charge_gas(evm, message_call_gas.cost + extend_memory.cost)
372
    if evm.message.is_static and value != U256(0):
373
        raise WriteInStaticContext
374
    evm.memory += b"\x00" * extend_memory.expand_by
375
    sender_balance = get_account(
376
        evm.message.block_env.state, evm.message.current_target
377
    ).balance
378
    if sender_balance < value:
379
        push(evm.stack, U256(0))
380
        evm.return_data = b""
381
        evm.gas_left += message_call_gas.sub_call
382
    else:
383
        generic_call(
384
            evm,
385
            message_call_gas.sub_call,
386
            value,
387
            evm.message.current_target,
388
            to,
389
            code_address,
390
            True,
391
            False,
392
            memory_input_start_position,
393
            memory_input_size,
394
            memory_output_start_position,
395
            memory_output_size,
396
        )
397
398
    # PROGRAM COUNTER
399
    evm.pc += Uint(1)

callcode

Message-call into this account with alternative account’s code.

Parameters

evm : The current EVM frame.

def callcode(​evm: Evm​) -> None:
403
    """
404
    Message-call into this account with alternative account’s code.
405
406
    Parameters
407
    ----------
408
    evm :
409
        The current EVM frame.
410
411
    """
412
    # STACK
413
    gas = Uint(pop(evm.stack))
414
    code_address = to_address_masked(pop(evm.stack))
415
    value = pop(evm.stack)
416
    memory_input_start_position = pop(evm.stack)
417
    memory_input_size = pop(evm.stack)
418
    memory_output_start_position = pop(evm.stack)
419
    memory_output_size = pop(evm.stack)
420
421
    # GAS
422
    to = evm.message.current_target
423
424
    extend_memory = calculate_gas_extend_memory(
425
        evm.memory,
426
        [
427
            (memory_input_start_position, memory_input_size),
428
            (memory_output_start_position, memory_output_size),
429
        ],
430
    )
431
432
    if code_address in evm.accessed_addresses:
433
        access_gas_cost = GAS_WARM_ACCESS
434
    else:
435
        evm.accessed_addresses.add(code_address)
436
        access_gas_cost = GAS_COLD_ACCOUNT_ACCESS
437
438
    transfer_gas_cost = Uint(0) if value == 0 else GAS_CALL_VALUE
439
    message_call_gas = calculate_message_call_gas(
440
        value,
441
        gas,
442
        Uint(evm.gas_left),
443
        extend_memory.cost,
444
        access_gas_cost + transfer_gas_cost,
445
    )
446
    charge_gas(evm, message_call_gas.cost + extend_memory.cost)
447
448
    # OPERATION
449
    evm.memory += b"\x00" * extend_memory.expand_by
450
    sender_balance = get_account(
451
        evm.message.block_env.state, evm.message.current_target
452
    ).balance
453
    if sender_balance < value:
454
        push(evm.stack, U256(0))
455
        evm.return_data = b""
456
        evm.gas_left += message_call_gas.sub_call
457
    else:
458
        generic_call(
459
            evm,
460
            message_call_gas.sub_call,
461
            value,
462
            evm.message.current_target,
463
            to,
464
            code_address,
465
            True,
466
            False,
467
            memory_input_start_position,
468
            memory_input_size,
469
            memory_output_start_position,
470
            memory_output_size,
471
        )
472
473
    # PROGRAM COUNTER
474
    evm.pc += Uint(1)

selfdestruct

Halt execution and register account for later deletion.

Parameters

evm : The current EVM frame.

def selfdestruct(​evm: Evm​) -> None:
478
    """
479
    Halt execution and register account for later deletion.
480
481
    Parameters
482
    ----------
483
    evm :
484
        The current EVM frame.
485
486
    """
487
    # STACK
488
    beneficiary = to_address_masked(pop(evm.stack))
489
490
    # GAS
491
    gas_cost = GAS_SELF_DESTRUCT
492
    if beneficiary not in evm.accessed_addresses:
493
        evm.accessed_addresses.add(beneficiary)
494
        gas_cost += GAS_COLD_ACCOUNT_ACCESS
495
496
    if (
497
        not is_account_alive(evm.message.block_env.state, beneficiary)
498
        and get_account(
499
            evm.message.block_env.state, evm.message.current_target
500
        ).balance
501
        != 0
502
    ):
503
        gas_cost += GAS_SELF_DESTRUCT_NEW_ACCOUNT
504
505
    originator = evm.message.current_target
506
507
    refunded_accounts = evm.accounts_to_delete
508
    parent_evm = evm.message.parent_evm
509
    while parent_evm is not None:
510
        refunded_accounts.update(parent_evm.accounts_to_delete)
511
        parent_evm = parent_evm.message.parent_evm
512
513
    if originator not in refunded_accounts:
514
        evm.refund_counter += REFUND_SELF_DESTRUCT
515
516
    charge_gas(evm, gas_cost)
517
    if evm.message.is_static:
518
        raise WriteInStaticContext
519
520
    originator = evm.message.current_target
521
    beneficiary_balance = get_account(
522
        evm.message.block_env.state, beneficiary
523
    ).balance
524
    originator_balance = get_account(
525
        evm.message.block_env.state, originator
526
    ).balance
527
528
    # First Transfer to beneficiary
529
    set_account_balance(
530
        evm.message.block_env.state,
531
        beneficiary,
532
        beneficiary_balance + originator_balance,
533
    )
534
    # Next, Zero the balance of the address being deleted (must come after
535
    # sending to beneficiary in case the contract named itself as the
536
    # beneficiary).
537
    set_account_balance(evm.message.block_env.state, originator, U256(0))
538
539
    # register account for deletion
540
    evm.accounts_to_delete.add(originator)
541
542
    # mark beneficiary as touched
543
    if account_exists_and_is_empty(evm.message.block_env.state, beneficiary):
544
        evm.touched_accounts.add(beneficiary)
545
546
    # HALT the execution
547
    evm.running = False
548
549
    # PROGRAM COUNTER
550
    pass

delegatecall

Message-call into an account.

Parameters

evm : The current EVM frame.

def delegatecall(​evm: Evm​) -> None:
554
    """
555
    Message-call into an account.
556
557
    Parameters
558
    ----------
559
    evm :
560
        The current EVM frame.
561
562
    """
563
    # STACK
564
    gas = Uint(pop(evm.stack))
565
    code_address = to_address_masked(pop(evm.stack))
566
    memory_input_start_position = pop(evm.stack)
567
    memory_input_size = pop(evm.stack)
568
    memory_output_start_position = pop(evm.stack)
569
    memory_output_size = pop(evm.stack)
570
571
    # GAS
572
    extend_memory = calculate_gas_extend_memory(
573
        evm.memory,
574
        [
575
            (memory_input_start_position, memory_input_size),
576
            (memory_output_start_position, memory_output_size),
577
        ],
578
    )
579
580
    if code_address in evm.accessed_addresses:
581
        access_gas_cost = GAS_WARM_ACCESS
582
    else:
583
        evm.accessed_addresses.add(code_address)
584
        access_gas_cost = GAS_COLD_ACCOUNT_ACCESS
585
586
    message_call_gas = calculate_message_call_gas(
587
        U256(0), gas, Uint(evm.gas_left), extend_memory.cost, access_gas_cost
588
    )
589
    charge_gas(evm, message_call_gas.cost + extend_memory.cost)
590
591
    # OPERATION
592
    evm.memory += b"\x00" * extend_memory.expand_by
593
    generic_call(
594
        evm,
595
        message_call_gas.sub_call,
596
        evm.message.value,
597
        evm.message.caller,
598
        evm.message.current_target,
599
        code_address,
600
        False,
601
        False,
602
        memory_input_start_position,
603
        memory_input_size,
604
        memory_output_start_position,
605
        memory_output_size,
606
    )
607
608
    # PROGRAM COUNTER
609
    evm.pc += Uint(1)

staticcall

Message-call into an account.

Parameters

evm : The current EVM frame.

def staticcall(​evm: Evm​) -> None:
613
    """
614
    Message-call into an account.
615
616
    Parameters
617
    ----------
618
    evm :
619
        The current EVM frame.
620
621
    """
622
    # STACK
623
    gas = Uint(pop(evm.stack))
624
    to = to_address_masked(pop(evm.stack))
625
    memory_input_start_position = pop(evm.stack)
626
    memory_input_size = pop(evm.stack)
627
    memory_output_start_position = pop(evm.stack)
628
    memory_output_size = pop(evm.stack)
629
630
    # GAS
631
    extend_memory = calculate_gas_extend_memory(
632
        evm.memory,
633
        [
634
            (memory_input_start_position, memory_input_size),
635
            (memory_output_start_position, memory_output_size),
636
        ],
637
    )
638
639
    if to in evm.accessed_addresses:
640
        access_gas_cost = GAS_WARM_ACCESS
641
    else:
642
        evm.accessed_addresses.add(to)
643
        access_gas_cost = GAS_COLD_ACCOUNT_ACCESS
644
645
    code_address = to
646
647
    message_call_gas = calculate_message_call_gas(
648
        U256(0),
649
        gas,
650
        Uint(evm.gas_left),
651
        extend_memory.cost,
652
        access_gas_cost,
653
    )
654
    charge_gas(evm, message_call_gas.cost + extend_memory.cost)
655
656
    # OPERATION
657
    evm.memory += b"\x00" * extend_memory.expand_by
658
    generic_call(
659
        evm,
660
        message_call_gas.sub_call,
661
        U256(0),
662
        evm.message.current_target,
663
        to,
664
        code_address,
665
        True,
666
        True,
667
        memory_input_start_position,
668
        memory_input_size,
669
        memory_output_start_position,
670
        memory_output_size,
671
    )
672
673
    # PROGRAM COUNTER
674
    evm.pc += Uint(1)

revert

Stop execution and revert state changes, without consuming all provided gas and also has the ability to return a reason.

Parameters

evm : The current EVM frame.

def revert(​evm: Evm​) -> None:
678
    """
679
    Stop execution and revert state changes, without consuming all provided gas
680
    and also has the ability to return a reason.
681
682
    Parameters
683
    ----------
684
    evm :
685
        The current EVM frame.
686
687
    """
688
    # STACK
689
    memory_start_index = pop(evm.stack)
690
    size = pop(evm.stack)
691
692
    # GAS
693
    extend_memory = calculate_gas_extend_memory(
694
        evm.memory, [(memory_start_index, size)]
695
    )
696
697
    charge_gas(evm, extend_memory.cost)
698
699
    # OPERATION
700
    evm.memory += b"\x00" * extend_memory.expand_by
701
    output = memory_read_bytes(evm.memory, memory_start_index, size)
702
    evm.output = Bytes(output)
703
    raise Revert