ethereum.byzantium.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

60
STACK_DEPTH_LIMIT = Uint(1024)

MAX_CODE_SIZE

61
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.
64
@dataclass
class MessageCallOutput:

gas_left

79
    gas_left: Uint

refund_counter

80
    refund_counter: U256

logs

81
    logs: Tuple[Log, ...]

accounts_to_delete

82
    accounts_to_delete: Set[Address]

touched_accounts

83
    touched_accounts: Iterable[Address]

error

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

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.byzantium.vm.Evm Items containing execution specific objects.

def process_create_message(message: Message, ​​env: Environment) -> Evm:
149
    """
150
    Executes a call to create a smart contract.
151
152
    Parameters
153
    ----------
154
    message :
155
        Transaction specific items.
156
    env :
157
        External items required for EVM execution.
158
159
    Returns
160
    -------
161
    evm: :py:class:`~ethereum.byzantium.vm.Evm`
162
        Items containing execution specific objects.
163
    """
164
    # take snapshot of state before processing the message
165
    begin_transaction(env.state)
166
167
    # If the address where the account is being created has storage, it is
168
    # destroyed. This can only happen in the following highly unlikely
169
    # circumstances:
170
    # * The address created by two `CREATE` calls collide.
171
    # * The first `CREATE` happened before Spurious Dragon and left empty
172
    #   code.
173
    destroy_storage(env.state, message.current_target)
174
175
    increment_nonce(env.state, message.current_target)
176
    evm = process_message(message, env)
177
    if not evm.error:
178
        contract_code = evm.output
179
        contract_code_gas = Uint(len(contract_code)) * GAS_CODE_DEPOSIT
180
        try:
181
            charge_gas(evm, contract_code_gas)
182
            if len(contract_code) > MAX_CODE_SIZE:
183
                raise OutOfGasError
184
        except ExceptionalHalt as error:
185
            rollback_transaction(env.state)
186
            evm.gas_left = Uint(0)
187
            evm.output = b""
188
            evm.error = error
189
        else:
190
            set_code(env.state, message.current_target, contract_code)
191
            commit_transaction(env.state)
192
    else:
193
        rollback_transaction(env.state)
194
    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.byzantium.vm.Evm Items containing execution specific objects

def process_message(message: Message, ​​env: Environment) -> Evm:
198
    """
199
    Executes a call to create a smart contract.
200
201
    Parameters
202
    ----------
203
    message :
204
        Transaction specific items.
205
    env :
206
        External items required for EVM execution.
207
208
    Returns
209
    -------
210
    evm: :py:class:`~ethereum.byzantium.vm.Evm`
211
        Items containing execution specific objects
212
    """
213
    if message.depth > STACK_DEPTH_LIMIT:
214
        raise StackDepthLimitError("Stack depth limit reached")
215
216
    # take snapshot of state before processing the message
217
    begin_transaction(env.state)
218
219
    touch_account(env.state, message.current_target)
220
221
    if message.should_transfer_value and message.value != 0:
222
        move_ether(
223
            env.state, message.caller, message.current_target, message.value
224
        )
225
226
    evm = execute_code(message, env)
227
    if evm.error:
228
        # revert state to the last saved checkpoint
229
        # since the message call resulted in an error
230
        rollback_transaction(env.state)
231
    else:
232
        commit_transaction(env.state)
233
    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:
237
    """
238
    Executes bytecode present in the `message`.
239
240
    Parameters
241
    ----------
242
    message :
243
        Transaction specific items.
244
    env :
245
        External items required for EVM execution.
246
247
    Returns
248
    -------
249
    evm: `ethereum.vm.EVM`
250
        Items containing execution specific objects
251
    """
252
    code = message.code
253
    valid_jump_destinations = get_valid_jump_destinations(code)
254
255
    evm = Evm(
256
        pc=Uint(0),
257
        stack=[],
258
        memory=bytearray(),
259
        code=code,
260
        gas_left=message.gas,
261
        env=env,
262
        valid_jump_destinations=valid_jump_destinations,
263
        logs=(),
264
        refund_counter=0,
265
        running=True,
266
        message=message,
267
        output=b"",
268
        accounts_to_delete=set(),
269
        touched_accounts=set(),
270
        return_data=b"",
271
        error=None,
272
    )
273
    try:
274
        if evm.message.code_address in PRE_COMPILED_CONTRACTS:
275
            evm_trace(evm, PrecompileStart(evm.message.code_address))
276
            PRE_COMPILED_CONTRACTS[evm.message.code_address](evm)
277
            evm_trace(evm, PrecompileEnd())
278
            return evm
279
280
        while evm.running and evm.pc < ulen(evm.code):
281
            try:
282
                op = Ops(evm.code[evm.pc])
283
            except ValueError:
284
                raise InvalidOpcode(evm.code[evm.pc])
285
286
            evm_trace(evm, OpStart(op))
287
            op_implementation[op](evm)
288
            evm_trace(evm, OpEnd())
289
290
        evm_trace(evm, EvmStop(Ops.STOP))
291
292
    except ExceptionalHalt as error:
293
        evm_trace(evm, OpException(error))
294
        evm.gas_left = Uint(0)
295
        evm.output = b""
296
        evm.error = error
297
    except Revert as error:
298
        evm_trace(evm, OpException(error))
299
        evm.error = error
300
    return evm