oracle like approach

Author: kevaundray

src/ethereum/osaka/fork.py

@@ -13,7 +13,7 @@
 """
 
 from dataclasses import dataclass
-from typing import Any, List, Optional, Tuple
+from typing import List, Optional, Tuple
 
 from ethereum_rlp import rlp
 from ethereum_types.bytes import Bytes
@@ -179,9 +179,7 @@ def get_last_256_block_hashes(chain: BlockChain) -> List[Hash32]:
     return recent_block_hashes
 
 
-def state_transition(
-    chain: BlockChain, block: Block, oracle: Optional[Any] = None
-) -> None:
+def state_transition(chain: BlockChain, block: Block) -> None:
     """
     Attempts to apply a block to an existing block chain.
 
@@ -212,13 +210,9 @@ def state_transition(
     if block.ommers != ():
         raise InvalidBlock
 
-    # Oracle must be provided
-    if oracle is None:
-        raise ValueError("Oracle parameter is required for state_transition")
-
     block_env = vm.BlockEnvironment(
         chain_id=chain.chain_id,
-        oracle=oracle,
+        state=chain.state,
         block_gas_limit=block.header.gas_limit,
         block_hashes=get_last_256_block_hashes(chain),
         coinbase=block.header.coinbase,
@@ -235,7 +229,7 @@ def state_transition(
         transactions=block.transactions,
         withdrawals=block.withdrawals,
     )
-    block_state_root = block_env.oracle.state_root()
+    block_state_root = block_env.get_oracle().state_root()
     transactions_root = root(block_output.transactions_trie)
     receipt_root = root(block_output.receipts_trie)
     block_logs_bloom = logs_bloom(block_output.block_logs)
@@ -459,7 +453,7 @@ def check_transaction(
         raise BlobGasLimitExceededError("blob gas limit exceeded")
 
     sender_address = recover_sender(block_env.chain_id, tx)
-    sender_account = block_env.oracle.get_account(sender_address)
+    sender_account = block_env.get_oracle().get_account(sender_address)
 
     if isinstance(
         tx, (FeeMarketTransaction, BlobTransaction, SetCodeTransaction)
@@ -664,7 +658,9 @@ def process_checked_system_transaction(
     system_tx_output : `MessageCallOutput`
         Output of processing the system transaction.
     """
-    system_contract_code = block_env.oracle.get_account(target_address).code
+    system_contract_code = (
+        block_env.get_oracle().get_account(target_address).code
+    )
 
     if len(system_contract_code) == 0:
         raise InvalidBlock(
@@ -711,7 +707,9 @@ def process_unchecked_system_transaction(
     system_tx_output : `MessageCallOutput`
         Output of processing the system transaction.
     """
-    system_contract_code = block_env.oracle.get_account(target_address).code
+    system_contract_code = (
+        block_env.get_oracle().get_account(target_address).code
+    )
     return process_system_transaction(
         block_env,
         target_address,
@@ -868,7 +866,7 @@ def process_transaction(
         tx=tx,
     )
 
-    sender_account = block_env.oracle.get_account(sender)
+    sender_account = block_env.get_oracle().get_account(sender)
 
     if isinstance(tx, BlobTransaction):
         blob_gas_fee = calculate_data_fee(block_env.excess_blob_gas, tx)
@@ -878,12 +876,12 @@ def process_transaction(
     effective_gas_fee = tx.gas * effective_gas_price
 
     gas = tx.gas - intrinsic_gas
-    block_env.oracle.increment_nonce(sender)
+    block_env.get_oracle().increment_nonce(sender)
 
     sender_balance_after_gas_fee = (
         Uint(sender_account.balance) - effective_gas_fee - blob_gas_fee
     )
-    block_env.oracle.set_account_balance(
+    block_env.get_oracle().set_account_balance(
         sender, U256(sender_balance_after_gas_fee)
     )
 
@@ -947,29 +945,33 @@ def process_transaction(
     transaction_fee = tx_gas_used_after_refund * priority_fee_per_gas
 
     # refund gas
-    current_sender_balance = block_env.oracle.get_account(sender).balance
+    current_sender_balance = block_env.get_oracle().get_account(sender).balance
     sender_balance_after_refund = current_sender_balance + U256(
         gas_refund_amount
     )
-    block_env.oracle.set_account_balance(sender, sender_balance_after_refund)
+    block_env.get_oracle().set_account_balance(
+        sender, sender_balance_after_refund
+    )
 
     # transfer miner fees
-    current_coinbase_balance = block_env.oracle.get_account(
-        block_env.coinbase
-    ).balance
+    current_coinbase_balance = (
+        block_env.get_oracle().get_account(block_env.coinbase).balance
+    )
     coinbase_balance_after_mining_fee = current_coinbase_balance + U256(
         transaction_fee
     )
     if coinbase_balance_after_mining_fee != 0:
-        block_env.oracle.set_account_balance(
+        block_env.get_oracle().set_account_balance(
             block_env.coinbase,
             coinbase_balance_after_mining_fee,
         )
-    elif block_env.oracle.account_exists_and_is_empty(block_env.coinbase):
-        block_env.oracle.destroy_account(block_env.coinbase)
+    elif block_env.get_oracle().account_exists_and_is_empty(
+        block_env.coinbase
+    ):
+        block_env.get_oracle().destroy_account(block_env.coinbase)
 
     for address in tx_output.accounts_to_delete:
-        block_env.oracle.destroy_account(address)
+        block_env.get_oracle().destroy_account(address)
 
     block_output.block_gas_used += tx_gas_used_after_refund
     block_output.blob_gas_used += tx_blob_gas_used
@@ -1009,10 +1011,12 @@ def increase_recipient_balance(recipient: Account) -> None:
             rlp.encode(wd),
         )
 
-        block_env.oracle.modify_state(wd.address, increase_recipient_balance)
+        block_env.get_oracle().modify_state(
+            wd.address, increase_recipient_balance
+        )
 
-        if block_env.oracle.account_exists_and_is_empty(wd.address):
-            block_env.oracle.destroy_account(wd.address)
+        if block_env.get_oracle().account_exists_and_is_empty(wd.address):
+            block_env.get_oracle().destroy_account(wd.address)
 
 
 def check_gas_limit(gas_limit: Uint, parent_gas_limit: Uint) -> bool:

src/ethereum/osaka/utils/message.py

@@ -53,15 +53,15 @@ def prepare_message(
     if isinstance(tx.to, Bytes0):
         current_target = compute_contract_address(
             tx_env.origin,
-            block_env.oracle.get_account(tx_env.origin).nonce - Uint(1),
+            block_env.get_oracle().get_account(tx_env.origin).nonce - Uint(1),
         )
         msg_data = Bytes(b"")
         code = tx.data
         code_address = None
     elif isinstance(tx.to, Address):
         current_target = tx.to
         msg_data = tx.data
-        code = block_env.oracle.get_account(tx.to).code
+        code = block_env.get_oracle().get_account(tx.to).code
         code_address = tx.to
     else:
         raise AssertionError("Target must be address or empty bytes")

src/ethereum/osaka/vm/__init__.py

@@ -14,18 +14,17 @@
 """
 
 from dataclasses import dataclass, field
-from typing import List, Optional, Set, Tuple
+from typing import Any, List, Optional, Set, Tuple
 
 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 ethereum.state_oracle import MerkleOracle
 
 from ..blocks import Log, Receipt, Withdrawal
 from ..fork_types import Address, Authorization, VersionedHash
-from ..state import TransientStorage
+from ..state import State, TransientStorage
 from ..transactions import LegacyTransaction
 from ..trie import Trie
 
@@ -39,7 +38,8 @@ class BlockEnvironment:
     """
 
     chain_id: U64
-    oracle: MerkleOracle
+    # TODO: Remove, this is no longer being used. Kept so all tests don't break for now.
+    state: State
     block_gas_limit: Uint
     block_hashes: List[Hash32]
     coinbase: Address
@@ -50,6 +50,16 @@ class BlockEnvironment:
     excess_blob_gas: U64
     parent_beacon_block_root: Hash32
 
+    def get_oracle(self) -> Any:
+        """
+        Get the state oracle.
+
+        Returns the global oracle (raises error if not set).
+        """
+        from ethereum.state_oracle import get_state_oracle
+
+        return get_state_oracle()
+
 
 @dataclass
 class BlockOutput:

src/ethereum/osaka/vm/eoa_delegation.py

@@ -128,7 +128,7 @@ def access_delegation(
     delegation : `Tuple[bool, Address, Bytes, Uint]`
         The delegation address, code, and access gas cost.
     """
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     code = oracle.get_account(address).code
     if not is_valid_delegation(code):
         return False, address, code, Uint(0)
@@ -160,7 +160,7 @@ def set_delegation(message: Message) -> U256:
     refund_counter: `U256`
         Refund from authority which already exists in state.
     """
-    oracle = message.block_env.oracle
+    oracle = message.block_env.get_oracle()
     refund_counter = U256(0)
     for auth in message.tx_env.authorizations:
         if auth.chain_id not in (message.block_env.chain_id, U256(0)):

src/ethereum/osaka/vm/instructions/environment.py

@@ -83,7 +83,7 @@ def balance(evm: Evm) -> None:
         charge_gas(evm, GAS_COLD_ACCOUNT_ACCESS)
 
     # OPERATION
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     # Non-existent accounts default to EMPTY_ACCOUNT, which has balance 0.
     balance = oracle.get_account(address).balance
 
@@ -351,7 +351,7 @@ def extcodesize(evm: Evm) -> None:
     charge_gas(evm, access_gas_cost)
 
     # OPERATION
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     code = oracle.get_account(address).code
 
     codesize = U256(len(code))
@@ -394,7 +394,7 @@ def extcodecopy(evm: Evm) -> None:
 
     # OPERATION
     evm.memory += b"\x00" * extend_memory.expand_by
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     code = oracle.get_account(address).code
 
     value = buffer_read(code, code_start_index, size)
@@ -481,7 +481,7 @@ def extcodehash(evm: Evm) -> None:
     charge_gas(evm, access_gas_cost)
 
     # OPERATION
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     account = oracle.get_account(address)
 
     if account == EMPTY_ACCOUNT:
@@ -513,7 +513,7 @@ def self_balance(evm: Evm) -> None:
     charge_gas(evm, GAS_FAST_STEP)
 
     # OPERATION
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     # Non-existent accounts default to EMPTY_ACCOUNT, which has balance 0.
     balance = oracle.get_account(evm.message.current_target).balance
 

src/ethereum/osaka/vm/instructions/storage.py

@@ -51,7 +51,7 @@ def sload(evm: Evm) -> None:
         charge_gas(evm, GAS_COLD_SLOAD)
 
     # OPERATION
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     value_bytes = oracle.get_storage(evm.message.current_target, key)
     value = U256.from_be_bytes(value_bytes)
 
@@ -77,7 +77,7 @@ def sstore(evm: Evm) -> None:
     if evm.gas_left <= GAS_CALL_STIPEND:
         raise OutOfGasError
 
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     original_value_bytes = oracle.get_storage_original(
         evm.message.current_target, key
     )

src/ethereum/osaka/vm/instructions/system.py

@@ -82,7 +82,7 @@ def generic_create(
     evm.return_data = b""
 
     sender_address = evm.message.current_target
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     sender = oracle.get_account(sender_address)
 
     if (
@@ -159,7 +159,7 @@ def create(evm: Evm) -> None:
     charge_gas(evm, GAS_CREATE + extend_memory.cost + init_code_gas)
 
     # OPERATION
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     evm.memory += b"\x00" * extend_memory.expand_by
     contract_address = compute_contract_address(
         evm.message.current_target,
@@ -374,7 +374,7 @@ def call(evm: Evm) -> None:
     ) = access_delegation(evm, code_address)
     access_gas_cost += delegated_access_gas_cost
 
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     create_gas_cost = GAS_NEW_ACCOUNT
     if value == 0 or oracle.is_account_alive(to):
         create_gas_cost = Uint(0)
@@ -471,7 +471,7 @@ def callcode(evm: Evm) -> None:
     charge_gas(evm, message_call_gas.cost + extend_memory.cost)
 
     # OPERATION
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     evm.memory += b"\x00" * extend_memory.expand_by
     sender_balance = oracle.get_account(evm.message.current_target).balance
     if sender_balance < value:
@@ -518,7 +518,7 @@ def selfdestruct(evm: Evm) -> None:
         evm.accessed_addresses.add(beneficiary)
         gas_cost += GAS_COLD_ACCOUNT_ACCESS
 
-    oracle = evm.message.block_env.oracle
+    oracle = evm.message.block_env.get_oracle()
     current_balance = oracle.get_account(evm.message.current_target).balance
 
     if not oracle.is_account_alive(beneficiary) and current_balance != 0: