Refactor Environment (#1131)

* refactor blob gas logic

There are parallels between how the regular block gas is handled and how the blob gas is handled. This commit
refactors blob gas canculation to bring them in line with block gas

* create BlockEnvironment and TransactionEnvironment

Create the BlockEnvironment and TransactionEnvironment dataclasses

BlockEnvironment holds data that is chain or block scoped
TransactionEnvironment holds data that is transaction scoped
Message holds data that is specific to a message call

* refactor validate_header

* update t8n

* update evm tracing

* backport changes to cancun

* port to shanghai

* port changes to paris

* port to london

* port berlin

* port istanbul

* port constantinople

* port byzantium

* port spurious_dragon

* port older forks

* fix t8n receipts

* update testing

* process_withdrawals update

* fixes for doc

* remove execution_spec_tests entry

The tests from execution_spec_tests should now be a part of EEST

* use default_factory in BlockOutput

* minor fixes 1

* define current_block_number in block_hash opcode

* rename tx_index to index_in_block

* fix vm test runs

Author: gurukamath

src/ethereum/arrow_glacier/fork.py

@@ -17,7 +17,7 @@
 `EMPTY_ACCOUNT`.
 """
 from dataclasses import dataclass, field
-from typing import Callable, Dict, List, Optional, Set, Tuple
+from typing import Callable, Dict, Iterable, List, Optional, Set, Tuple
 
 from ethereum_types.bytes import Bytes
 from ethereum_types.frozen import modify
@@ -630,3 +630,20 @@ def get_storage_original(state: State, address: Address, key: Bytes) -> U256:
     assert isinstance(original_value, U256)
 
     return original_value
+
+
+def destroy_touched_empty_accounts(
+    state: State, touched_accounts: Iterable[Address]
+) -> None:
+    """
+    Destroy all touched accounts that are empty.
+    Parameters
+    ----------
+    state: `State`
+        The current state.
+    touched_accounts: `Iterable[Address]`
+        All the accounts that have been touched in the current transaction.
+    """
+    for address in touched_accounts:
+        if account_exists_and_is_empty(state, address):
+            destroy_account(state, address)

src/ethereum/arrow_glacier/state.py

@@ -9,7 +9,7 @@
 from ethereum_rlp import rlp
 from ethereum_types.bytes import Bytes, Bytes0, Bytes32
 from ethereum_types.frozen import slotted_freezable
-from ethereum_types.numeric import U64, U256, Uint
+from ethereum_types.numeric import U64, U256, Uint, ulen
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
@@ -18,12 +18,12 @@
 from .exceptions import TransactionTypeError
 from .fork_types import Address
 
-TX_BASE_COST = 21000
-TX_DATA_COST_PER_NON_ZERO = 16
-TX_DATA_COST_PER_ZERO = 4
-TX_CREATE_COST = 32000
-TX_ACCESS_LIST_ADDRESS_COST = 2400
-TX_ACCESS_LIST_STORAGE_KEY_COST = 1900
+TX_BASE_COST = Uint(21000)
+TX_DATA_COST_PER_NON_ZERO = Uint(16)
+TX_DATA_COST_PER_ZERO = Uint(4)
+TX_CREATE_COST = Uint(32000)
+TX_ACCESS_LIST_ADDRESS_COST = Uint(2400)
+TX_ACCESS_LIST_STORAGE_KEY_COST = Uint(1900)
 
 
 @slotted_freezable
@@ -177,10 +177,10 @@ def calculate_intrinsic_cost(tx: Transaction) -> Uint:
 
     Returns
     -------
-    verified : `ethereum.base_types.Uint`
+    intrinsic_gas : `ethereum.base_types.Uint`
         The intrinsic cost of the transaction.
     """
-    data_cost = 0
+    data_cost = Uint(0)
 
     for byte in tx.data:
         if byte == 0:
@@ -191,15 +191,15 @@ def calculate_intrinsic_cost(tx: Transaction) -> Uint:
     if tx.to == Bytes0(b""):
         create_cost = TX_CREATE_COST
     else:
-        create_cost = 0
+        create_cost = Uint(0)
 
-    access_list_cost = 0
+    access_list_cost = Uint(0)
     if isinstance(tx, (AccessListTransaction, FeeMarketTransaction)):
         for _address, keys in tx.access_list:
             access_list_cost += TX_ACCESS_LIST_ADDRESS_COST
-            access_list_cost += len(keys) * TX_ACCESS_LIST_STORAGE_KEY_COST
+            access_list_cost += ulen(keys) * TX_ACCESS_LIST_STORAGE_KEY_COST
 
-    return Uint(TX_BASE_COST + data_cost + create_cost + access_list_cost)
+    return TX_BASE_COST + data_cost + create_cost + access_list_cost
 
 
 def recover_sender(chain_id: U64, tx: Transaction) -> Address:
@@ -380,3 +380,22 @@ def signing_hash_1559(tx: FeeMarketTransaction) -> Hash32:
             )
         )
     )
+
+
+def get_transaction_hash(tx: Union[Bytes, LegacyTransaction]) -> Hash32:
+    """
+    Parameters
+    ----------
+    tx :
+        Transaction of interest.
+
+    Returns
+    -------
+    hash : `ethereum.crypto.hash.Hash32`
+        Hash of the transaction.
+    """
+    assert isinstance(tx, (LegacyTransaction, Bytes))
+    if isinstance(tx, LegacyTransaction):
+        return keccak256(rlp.encode(tx))
+    else:
+        return keccak256(tx)

src/ethereum/arrow_glacier/transactions.py

@@ -12,105 +12,78 @@
 Message specific functions used in this arrow_glacier version of
 specification.
 """
-from typing import FrozenSet, Optional, Tuple, Union
-
-from ethereum_types.bytes import Bytes, Bytes0, Bytes32
-from ethereum_types.numeric import U256, Uint
+from ethereum_types.bytes import Bytes, Bytes0
+from ethereum_types.numeric import Uint
 
 from ..fork_types import Address
 from ..state import get_account
-from ..vm import Environment, Message
+from ..transactions import Transaction
+from ..vm import BlockEnvironment, Message, TransactionEnvironment
 from ..vm.precompiled_contracts.mapping import PRE_COMPILED_CONTRACTS
 from .address import compute_contract_address
 
 
 def prepare_message(
-    caller: Address,
-    target: Union[Bytes0, Address],
-    value: U256,
-    data: Bytes,
-    gas: Uint,
-    env: Environment,
-    code_address: Optional[Address] = None,
-    should_transfer_value: bool = True,
-    is_static: bool = False,
-    preaccessed_addresses: FrozenSet[Address] = frozenset(),
-    preaccessed_storage_keys: FrozenSet[
-        Tuple[(Address, Bytes32)]
-    ] = frozenset(),
+    block_env: BlockEnvironment,
+    tx_env: TransactionEnvironment,
+    tx: Transaction,
 ) -> Message:
     """
     Execute a transaction against the provided environment.
 
     Parameters
     ----------
-    caller :
-        Address which initiated the transaction
-    target :
-        Address whose code will be executed
-    value :
-        Value to be transferred.
-    data :
-        Array of bytes provided to the code in `target`.
-    gas :
-        Gas provided for the code in `target`.
-    env :
+    block_env :
         Environment for the Ethereum Virtual Machine.
-    code_address :
-        This is usually same as the `target` address except when an alternative
-        accounts code needs to be executed.
-        eg. `CALLCODE` calling a precompile.
-    should_transfer_value :
-        if True ETH should be transferred while executing a message call.
-    is_static:
-        if True then it prevents all state-changing operations from being
-        executed.
-    preaccessed_addresses:
-        Addresses that should be marked as accessed prior to the message call
-    preaccessed_storage_keys:
-        Storage keys that should be marked as accessed prior to the message
-        call
+    tx_env :
+        Environment for the transaction.
+    tx :
+        Transaction to be executed.
 
     Returns
     -------
     message: `ethereum.arrow_glacier.vm.Message`
         Items containing contract creation or message call specific data.
     """
     accessed_addresses = set()
-    accessed_addresses.add(caller)
+    accessed_addresses.add(tx_env.origin)
     accessed_addresses.update(PRE_COMPILED_CONTRACTS.keys())
-    accessed_addresses.update(preaccessed_addresses)
-    if isinstance(target, Bytes0):
+    accessed_addresses.update(tx_env.access_list_addresses)
+
+    if isinstance(tx.to, Bytes0):
         current_target = compute_contract_address(
-            caller,
-            get_account(env.state, caller).nonce - Uint(1),
+            tx_env.origin,
+            get_account(block_env.state, tx_env.origin).nonce - Uint(1),
         )
         msg_data = Bytes(b"")
-        code = data
-    elif isinstance(target, Address):
-        current_target = target
-        msg_data = data
-        code = get_account(env.state, target).code
-        if code_address is None:
-            code_address = target
+        code = tx.data
+        code_address = None
+    elif isinstance(tx.to, Address):
+        current_target = tx.to
+        msg_data = tx.data
+        code = get_account(block_env.state, tx.to).code
+
+        code_address = tx.to
     else:
         raise AssertionError("Target must be address or empty bytes")
 
     accessed_addresses.add(current_target)
 
     return Message(
-        caller=caller,
-        target=target,
-        gas=gas,
-        value=value,
+        block_env=block_env,
+        tx_env=tx_env,
+        caller=tx_env.origin,
+        target=tx.to,
+        gas=tx_env.gas,
+        value=tx.value,
         data=msg_data,
         code=code,
         depth=Uint(0),
         current_target=current_target,
         code_address=code_address,
-        should_transfer_value=should_transfer_value,
-        is_static=is_static,
+        should_transfer_value=True,
+        is_static=False,
         accessed_addresses=accessed_addresses,
-        accessed_storage_keys=set(preaccessed_storage_keys),
+        accessed_storage_keys=set(tx_env.access_list_storage_keys),
         parent_evm=None,
     )

src/ethereum/arrow_glacier/utils/message.py

@@ -13,40 +13,83 @@
 `.fork_types.Account`.
 """
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import List, Optional, Set, Tuple, Union
 
 from ethereum_types.bytes import Bytes, Bytes0, Bytes32
 from ethereum_types.numeric import U64, U256, Uint
 
 from ethereum.crypto.hash import Hash32
+from ethereum.exceptions import EthereumException
 
-from ..blocks import Log
+from ..blocks import Log, Receipt
 from ..fork_types import Address
 from ..state import State, account_exists_and_is_empty
+from ..transactions import LegacyTransaction
+from ..trie import Trie
 from .precompiled_contracts import RIPEMD160_ADDRESS
 
 __all__ = ("Environment", "Evm", "Message")
 
 
 @dataclass
-class Environment:
+class BlockEnvironment:
     """
     Items external to the virtual machine itself, provided by the environment.
     """
 
-    caller: Address
+    chain_id: U64
+    state: State
+    block_gas_limit: Uint
     block_hashes: List[Hash32]
-    origin: Address
     coinbase: Address
     number: Uint
     base_fee_per_gas: Uint
-    gas_limit: Uint
-    gas_price: Uint
     time: U256
     difficulty: Uint
-    state: State
-    chain_id: U64
+
+
+@dataclass
+class BlockOutput:
+    """
+    Output from applying the block body to the present state.
+
+    Contains the following:
+
+    block_gas_used : `ethereum.base_types.Uint`
+        Gas used for executing all transactions.
+    transactions_trie : `ethereum.fork_types.Root`
+        Trie of all the transactions in the block.
+    receipts_trie : `ethereum.fork_types.Root`
+        Trie root of all the receipts in the block.
+    block_logs : `Bloom`
+        Logs bloom of all the logs included in all the transactions of the
+        block.
+    """
+
+    block_gas_used: Uint = Uint(0)
+    transactions_trie: Trie[
+        Bytes, Optional[Union[Bytes, LegacyTransaction]]
+    ] = field(default_factory=lambda: Trie(secured=False, default=None))
+    receipts_trie: Trie[Bytes, Optional[Union[Bytes, Receipt]]] = field(
+        default_factory=lambda: Trie(secured=False, default=None)
+    )
+    block_logs: Tuple[Log, ...] = field(default_factory=tuple)
+
+
+@dataclass
+class TransactionEnvironment:
+    """
+    Items that are used by contract creation or message call.
+    """
+
+    origin: Address
+    gas_price: Uint
+    gas: Uint
+    access_list_addresses: Set[Address]
+    access_list_storage_keys: Set[Tuple[Address, Bytes32]]
+    index_in_block: Optional[Uint]
+    tx_hash: Optional[Hash32]
     traces: List[dict]
 
 
@@ -56,6 +99,8 @@ class Message:
     Items that are used by contract creation or message call.
     """
 
+    block_env: BlockEnvironment
+    tx_env: TransactionEnvironment
     caller: Address
     target: Union[Bytes0, Address]
     current_target: Address
@@ -81,7 +126,6 @@ class Evm:
     memory: bytearray
     code: Bytes
     gas_left: Uint
-    env: Environment
     valid_jump_destinations: Set[Uint]
     logs: Tuple[Log, ...]
     refund_counter: int
@@ -91,7 +135,7 @@ class Evm:
     accounts_to_delete: Set[Address]
     touched_accounts: Set[Address]
     return_data: Bytes
-    error: Optional[Exception]
+    error: Optional[EthereumException]
     accessed_addresses: Set[Address]
     accessed_storage_keys: Set[Tuple[Address, Bytes32]]
 
@@ -113,7 +157,7 @@ def incorporate_child_on_success(evm: Evm, child_evm: Evm) -> None:
     evm.accounts_to_delete.update(child_evm.accounts_to_delete)
     evm.touched_accounts.update(child_evm.touched_accounts)
     if account_exists_and_is_empty(
-        evm.env.state, child_evm.message.current_target
+        evm.message.block_env.state, child_evm.message.current_target
     ):
         evm.touched_accounts.add(child_evm.message.current_target)
     evm.accessed_addresses.update(child_evm.accessed_addresses)
@@ -142,7 +186,7 @@ def incorporate_child_on_error(evm: Evm, child_evm: Evm) -> None:
         evm.touched_accounts.add(RIPEMD160_ADDRESS)
     if child_evm.message.current_target == RIPEMD160_ADDRESS:
         if account_exists_and_is_empty(
-            evm.env.state, child_evm.message.current_target
+            evm.message.block_env.state, child_evm.message.current_target
         ):
             evm.touched_accounts.add(RIPEMD160_ADDRESS)
     evm.gas_left += child_evm.gas_left