ethereum.cancun.vm.interpreter

Ethereum Virtual Machine (EVM) Interpreter ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

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

Introduction

A straightforward interpreter that executes EVM code.

STACK_DEPTH_LIMIT

62
STACK_DEPTH_LIMIT = Uint(1024)

MAX_CODE_SIZE

63
MAX_CODE_SIZE = 0x6000

MessageCallOutput

Output of a particular message call

Contains the following:

  1. `gas_left`: remaining gas after execution.
  2. `refund_counter`: gas to refund after execution.
  3. `logs`: list of `Log` generated during execution.
  4. `accounts_to_delete`: Contracts which have self-destructed.
  5. `touched_accounts`: Accounts that have been touched.
  6. `error`: The error from the execution if any.
66
@dataclass
class MessageCallOutput:

gas_left

81
    gas_left: Uint

refund_counter

82
    refund_counter: U256

logs

83
    logs: Union[Tuple[()], Tuple[Log, ...]]

accounts_to_delete

84
    accounts_to_delete: Set[Address]

touched_accounts

85
    touched_accounts: Iterable[Address]

error

86
    error: Optional[Exception]

process_message_call

If message.current is empty then it creates a smart contract else it executes a call from the message.caller to the message.target.

Parameters

message : Transaction specific items.

env : External items required for EVM execution.

Returns

output : MessageCallOutput Output of the message call

def process_message_call(message: Message, ​​env: Environment) -> MessageCallOutput:
92
    """
93
    If `message.current` is empty then it creates a smart contract
94
    else it executes a call from the `message.caller` to the `message.target`.
95
96
    Parameters
97
    ----------
98
    message :
99
        Transaction specific items.
100
101
    env :
102
        External items required for EVM execution.
103
104
    Returns
105
    -------
106
    output : `MessageCallOutput`
107
        Output of the message call
108
    """
109
    if message.target == Bytes0(b""):
110
        is_collision = account_has_code_or_nonce(
111
            env.state, message.current_target
112
        )
113
        if is_collision:
114
            return MessageCallOutput(
115
                Uint(0), U256(0), tuple(), set(), set(), AddressCollision()
116
            )
117
        else:
118
            evm = process_create_message(message, env)
119
    else:
120
        evm = process_message(message, env)
121
        if account_exists_and_is_empty(env.state, Address(message.target)):
122
            evm.touched_accounts.add(Address(message.target))
123
124
    if evm.error:
125
        logs: Tuple[Log, ...] = ()
126
        accounts_to_delete = set()
127
        touched_accounts = set()
128
        refund_counter = U256(0)
129
    else:
130
        logs = evm.logs
131
        accounts_to_delete = evm.accounts_to_delete
132
        touched_accounts = evm.touched_accounts
133
        refund_counter = U256(evm.refund_counter)
134
135
    tx_end = TransactionEnd(
136
        int(message.gas) - int(evm.gas_left), evm.output, evm.error
137
    )
138
    evm_trace(evm, tx_end)
139
140
    return MessageCallOutput(
141
        gas_left=evm.gas_left,
142
        refund_counter=refund_counter,
143
        logs=logs,
144
        accounts_to_delete=accounts_to_delete,
145
        touched_accounts=touched_accounts,
146
        error=evm.error,
147
    )

process_create_message

Executes a call to create a smart contract.

Parameters

message : Transaction specific items. env : External items required for EVM execution.

Returns

evm: :py:class:~ethereum.cancun.vm.Evm Items containing execution specific objects.

def process_create_message(message: Message, ​​env: Environment) -> Evm:
151
    """
152
    Executes a call to create a smart contract.
153
154
    Parameters
155
    ----------
156
    message :
157
        Transaction specific items.
158
    env :
159
        External items required for EVM execution.
160
161
    Returns
162
    -------
163
    evm: :py:class:`~ethereum.cancun.vm.Evm`
164
        Items containing execution specific objects.
165
    """
166
    # take snapshot of state before processing the message
167
    begin_transaction(env.state, env.transient_storage)
168
169
    # If the address where the account is being created has storage, it is
170
    # destroyed. This can only happen in the following highly unlikely
171
    # circumstances:
172
    # * The address created by a `CREATE` call collides with a subsequent
173
    #   `CREATE` or `CREATE2` call.
174
    # * The first `CREATE` happened before Spurious Dragon and left empty
175
    #   code.
176
    destroy_storage(env.state, message.current_target)
177
178
    # In the previously mentioned edge case the preexisting storage is ignored
179
    # for gas refund purposes. In order to do this we must track created
180
    # accounts.
181
    mark_account_created(env.state, message.current_target)
182
183
    increment_nonce(env.state, message.current_target)
184
    evm = process_message(message, env)
185
    if not evm.error:
186
        contract_code = evm.output
187
        contract_code_gas = Uint(len(contract_code)) * GAS_CODE_DEPOSIT
188
        try:
189
            if len(contract_code) > 0:
190
                if contract_code[0] == 0xEF:
191
                    raise InvalidContractPrefix
192
            charge_gas(evm, contract_code_gas)
193
            if len(contract_code) > MAX_CODE_SIZE:
194
                raise OutOfGasError
195
        except ExceptionalHalt as error:
196
            rollback_transaction(env.state, env.transient_storage)
197
            evm.gas_left = Uint(0)
198
            evm.output = b""
199
            evm.error = error
200
        else:
201
            set_code(env.state, message.current_target, contract_code)
202
            commit_transaction(env.state, env.transient_storage)
203
    else:
204
        rollback_transaction(env.state, env.transient_storage)
205
    return evm

process_message

Executes a call to create a smart contract.

Parameters

message : Transaction specific items. env : External items required for EVM execution.

Returns

evm: :py:class:~ethereum.cancun.vm.Evm Items containing execution specific objects

def process_message(message: Message, ​​env: Environment) -> Evm:
209
    """
210
    Executes a call to create a smart contract.
211
212
    Parameters
213
    ----------
214
    message :
215
        Transaction specific items.
216
    env :
217
        External items required for EVM execution.
218
219
    Returns
220
    -------
221
    evm: :py:class:`~ethereum.cancun.vm.Evm`
222
        Items containing execution specific objects
223
    """
224
    if message.depth > STACK_DEPTH_LIMIT:
225
        raise StackDepthLimitError("Stack depth limit reached")
226
227
    # take snapshot of state before processing the message
228
    begin_transaction(env.state, env.transient_storage)
229
230
    touch_account(env.state, message.current_target)
231
232
    if message.should_transfer_value and message.value != 0:
233
        move_ether(
234
            env.state, message.caller, message.current_target, message.value
235
        )
236
237
    evm = execute_code(message, env)
238
    if evm.error:
239
        # revert state to the last saved checkpoint
240
        # since the message call resulted in an error
241
        rollback_transaction(env.state, env.transient_storage)
242
    else:
243
        commit_transaction(env.state, env.transient_storage)
244
    return evm

execute_code

Executes bytecode present in the message.

Parameters

message : Transaction specific items. env : External items required for EVM execution.

Returns

evm: ethereum.vm.EVM Items containing execution specific objects

def execute_code(message: Message, ​​env: Environment) -> Evm:
248
    """
249
    Executes bytecode present in the `message`.
250
251
    Parameters
252
    ----------
253
    message :
254
        Transaction specific items.
255
    env :
256
        External items required for EVM execution.
257
258
    Returns
259
    -------
260
    evm: `ethereum.vm.EVM`
261
        Items containing execution specific objects
262
    """
263
    code = message.code
264
    valid_jump_destinations = get_valid_jump_destinations(code)
265
266
    evm = Evm(
267
        pc=Uint(0),
268
        stack=[],
269
        memory=bytearray(),
270
        code=code,
271
        gas_left=message.gas,
272
        env=env,
273
        valid_jump_destinations=valid_jump_destinations,
274
        logs=(),
275
        refund_counter=0,
276
        running=True,
277
        message=message,
278
        output=b"",
279
        accounts_to_delete=set(),
280
        touched_accounts=set(),
281
        return_data=b"",
282
        error=None,
283
        accessed_addresses=message.accessed_addresses,
284
        accessed_storage_keys=message.accessed_storage_keys,
285
    )
286
    try:
287
        if evm.message.code_address in PRE_COMPILED_CONTRACTS:
288
            evm_trace(evm, PrecompileStart(evm.message.code_address))
289
            PRE_COMPILED_CONTRACTS[evm.message.code_address](evm)
290
            evm_trace(evm, PrecompileEnd())
291
            return evm
292
293
        while evm.running and evm.pc < ulen(evm.code):
294
            try:
295
                op = Ops(evm.code[evm.pc])
296
            except ValueError:
297
                raise InvalidOpcode(evm.code[evm.pc])
298
299
            evm_trace(evm, OpStart(op))
300
            op_implementation[op](evm)
301
            evm_trace(evm, OpEnd())
302
303
        evm_trace(evm, EvmStop(Ops.STOP))
304
305
    except ExceptionalHalt as error:
306
        evm_trace(evm, OpException(error))
307
        evm.gas_left = Uint(0)
308
        evm.output = b""
309
        evm.error = error
310
    except Revert as error:
311
        evm_trace(evm, OpException(error))
312
        evm.error = error
313
    return evm