ethereum.forks.homestead.vm.interpreterethereum.forks.dao_fork.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¶
| 57 | STACK_DEPTH_LIMIT = Uint(1024) |
|---|
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. `error`: The error from the execution if any.
| 60 | @final |
|---|
| 61 | @dataclass |
|---|
class MessageCallOutput:
gas_left¶
| 75 | gas_left: Uint |
|---|
refund_counter¶
| 76 | refund_counter: U256 |
|---|
logs¶
| 77 | logs: Tuple[Log, ...] |
|---|
accounts_to_delete¶
| 78 | accounts_to_delete: Set[Address] |
|---|
error¶
| 79 | error: Optional[EthereumException] |
|---|
process_message_call ¶
If message.target 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.
Returns
output : MessageCallOutput
Output of the message call
def process_message_call(message: Message) -> MessageCallOutput:
| 83 | <snip> |
|---|---|
| 98 | tx_state = message.tx_env.state |
| 99 | refund_counter = U256(0) |
| 100 | if message.target == Bytes0(b""): |
| 101 | is_collision = account_has_code_or_nonce( |
| 102 | tx_state, message.current_target |
| 103 | ) or account_has_storage(tx_state, message.current_target) |
| 104 | if is_collision: |
| 105 | return MessageCallOutput( |
| 106 | gas_left=Uint(0), |
| 107 | refund_counter=U256(0), |
| 108 | logs=tuple(), |
| 109 | accounts_to_delete=set(), |
| 110 | error=AddressCollision(), |
| 111 | ) |
| 112 | else: |
| 113 | evm = process_create_message(message) |
| 114 | else: |
| 115 | evm = process_message(message) |
| 116 | |
| 117 | if evm.error: |
| 118 | logs: Tuple[Log, ...] = () |
| 119 | accounts_to_delete = set() |
| 120 | else: |
| 121 | logs = evm.logs |
| 122 | accounts_to_delete = evm.accounts_to_delete |
| 123 | refund_counter += U256(evm.refund_counter) |
| 124 | |
| 125 | tx_end = TransactionEnd( |
| 126 | int(message.gas) - int(evm.gas_left), evm.output, evm.error |
| 127 | ) |
| 128 | evm_trace(evm, tx_end) |
| 129 | |
| 130 | return MessageCallOutput( |
| 131 | gas_left=evm.gas_left, |
| 132 | refund_counter=refund_counter, |
| 133 | logs=logs, |
| 134 | accounts_to_delete=accounts_to_delete, |
| 135 | error=evm.error, |
| 136 | ) |
process_create_message ¶
Executes a call to create a smart contract.
Parameters
message : Transaction specific items.
Returns
evm: :py:class:~ethereum.forks.homestead.vm.Evm~ethereum.forks.dao_fork.vm.Evm
def process_create_message(message: Message) -> Evm:
| 140 | <snip> |
|---|---|
| 154 | tx_state = message.tx_env.state |
| 155 | # take snapshot of state before processing the message |
| 156 | snapshot = copy_tx_state(tx_state) |
| 157 | |
| 158 | # If the address where the account is being created has storage, it is |
| 159 | # destroyed. This can only happen in the following highly unlikely |
| 160 | # circumstances: |
| 161 | # * The address created by a `CREATE` call collides with a subsequent |
| 162 | # `CREATE` call. |
| 163 | destroy_storage(tx_state, message.current_target) |
| 164 | |
| 165 | evm = process_message(message) |
| 166 | if not evm.error: |
| 167 | contract_code = evm.output |
| 168 | contract_code_gas = ( |
| 169 | ulen(contract_code) * GasCosts.CODE_DEPOSIT_PER_BYTE |
| 170 | ) |
| 171 | try: |
| 172 | charge_gas(evm, contract_code_gas) |
| 173 | except ExceptionalHalt as error: |
| 174 | restore_tx_state(tx_state, snapshot) |
| 175 | evm.gas_left = Uint(0) |
| 176 | evm.error = error |
| 177 | else: |
| 178 | set_code(tx_state, message.current_target, contract_code) |
| 179 | else: |
| 180 | restore_tx_state(tx_state, snapshot) |
| 181 | return evm |
process_message ¶
Move ether and execute the relevant code.
Parameters
message : Transaction specific items.
Returns
evm: :py:class:~ethereum.forks.homestead.vm.Evm~ethereum.forks.dao_fork.vm.Evm
def process_message(message: Message) -> Evm:
| 185 | <snip> |
|---|---|
| 199 | tx_state = message.tx_env.state |
| 200 | if message.depth > STACK_DEPTH_LIMIT: |
| 201 | raise StackDepthLimitError("Stack depth limit reached") |
| 202 | |
| 203 | code = message.code |
| 204 | valid_jump_destinations = get_valid_jump_destinations(code) |
| 205 | evm = Evm( |
| 206 | pc=Uint(0), |
| 207 | stack=[], |
| 208 | memory=bytearray(), |
| 209 | code=code, |
| 210 | gas_left=message.gas, |
| 211 | valid_jump_destinations=valid_jump_destinations, |
| 212 | logs=(), |
| 213 | refund_counter=0, |
| 214 | running=True, |
| 215 | message=message, |
| 216 | output=b"", |
| 217 | accounts_to_delete=set(), |
| 218 | error=None, |
| 219 | ) |
| 220 | |
| 221 | # take snapshot of state before processing the message |
| 222 | snapshot = copy_tx_state(tx_state) |
| 223 | |
| 224 | touch_account(tx_state, message.current_target) |
| 225 | |
| 226 | if message.should_transfer_value and message.value != 0: |
| 227 | move_ether( |
| 228 | tx_state, |
| 229 | message.caller, |
| 230 | message.current_target, |
| 231 | message.value, |
| 232 | ) |
| 233 | |
| 234 | try: |
| 235 | if evm.message.code_address in PRE_COMPILED_CONTRACTS: |
| 236 | evm_trace(evm, PrecompileStart(evm.message.code_address)) |
| 237 | PRE_COMPILED_CONTRACTS[evm.message.code_address](evm) |
| 238 | evm_trace(evm, PrecompileEnd()) |
| 239 | else: |
| 240 | while evm.running and evm.pc < ulen(evm.code): |
| 241 | try: |
| 242 | op = Ops(evm.code[evm.pc]) |
| 243 | except ValueError as e: |
| 244 | raise InvalidOpcode(evm.code[evm.pc]) from e |
| 245 | |
| 246 | evm_trace(evm, OpStart(op)) |
| 247 | op_implementation[op](evm) |
| 248 | evm_trace(evm, OpEnd()) |
| 249 | |
| 250 | evm_trace(evm, EvmStop(Ops.STOP)) |
| 251 | |
| 252 | except ExceptionalHalt as error: |
| 253 | evm_trace(evm, OpException(error)) |
| 254 | evm.gas_left = Uint(0) |
| 255 | evm.error = error |
| 256 | |
| 257 | if evm.error: |
| 258 | restore_tx_state(tx_state, snapshot) |
| 259 | return evm |