chore(spec-specs): cleanup BAL logic; organize gas check for SSTORE

Author: fselmo

src/ethereum/forks/amsterdam/fork.py

@@ -1093,9 +1093,6 @@ def process_transaction(
 
     block_output.block_logs += tx_output.logs
 
-    # EIP-7928: Handle in-transaction self-destruct BEFORE normalization
-    # Destroy accounts first so normalization sees correct post-tx state
-    # Only accounts created in same tx are in accounts_to_delete per EIP-6780
     for address in tx_output.accounts_to_delete:
         destroy_account(block_env.state, address)
 
@@ -1130,7 +1127,6 @@ def process_withdrawals(
     """
     Increase the balance of the withdrawing account.
     """
-    # Get block access index for withdrawals (post-exec phase)
     block_access_index = get_block_access_index(block_env.block_state_changes)
 
     # Capture pre-state for withdrawal balance filtering

src/ethereum/forks/amsterdam/state.py

@@ -538,11 +538,7 @@ def increase_recipient_balance(recipient: Account) -> None:
     modify_state(state, recipient_address, increase_recipient_balance)
 
 
-def set_account_balance(
-    state: State,
-    address: Address,
-    amount: U256,
-) -> None:
+def set_account_balance(state: State, address: Address, amount: U256) -> None:
     """
     Sets the balance of an account.
 

src/ethereum/forks/amsterdam/vm/eoa_delegation.py

@@ -261,19 +261,17 @@ def set_delegation(message: Message) -> U256:
             message.block_env.block_state_changes
         )
 
-        # Capture pre-code before any changes (first-write-wins)
+        # EIP-7928: Capture pre-code before any changes
         capture_pre_code(tx_frame, authority, authority_code)
 
-        # Set delegation code
         set_authority_code(state, authority, code_to_set)
 
-        # Track code change if different from current
         if authority_code != code_to_set:
+            # Track code change if different from current
             track_code_change(
                 tx_frame, authority, code_to_set, block_access_index
             )
 
-        # Track nonce increment
         increment_nonce(state, authority)
         nonce_after = get_account(state, authority).nonce
         track_nonce_change(

src/ethereum/forks/amsterdam/vm/instructions/storage.py

@@ -27,7 +27,7 @@
     track_storage_write,
 )
 from .. import Evm
-from ..exceptions import OutOfGasError, WriteInStaticContext
+from ..exceptions import WriteInStaticContext
 from ..gas import (
     GAS_CALL_STIPEND,
     GAS_COLD_SLOAD,
@@ -56,25 +56,26 @@ def sload(evm: Evm) -> None:
     key = pop(evm.stack).to_be_bytes32()
 
     # GAS
-    gas_cost = (
-        GAS_WARM_ACCESS
-        if (evm.message.current_target, key) in evm.accessed_storage_keys
-        else GAS_COLD_SLOAD
-    )
-    check_gas(evm, gas_cost)
-    if (evm.message.current_target, key) not in evm.accessed_storage_keys:
-        evm.accessed_storage_keys.add((evm.message.current_target, key))
-    track_storage_read(
-        evm.state_changes,
+    is_cold_access = (
         evm.message.current_target,
         key,
-    )
+    ) not in evm.accessed_storage_keys
+    gas_cost = GAS_COLD_SLOAD if is_cold_access else GAS_WARM_ACCESS
+
     charge_gas(evm, gas_cost)
 
     # OPERATION
     state = evm.message.block_env.state
     value = get_storage(state, evm.message.current_target, key)
 
+    if is_cold_access:
+        evm.accessed_storage_keys.add((evm.message.current_target, key))
+    track_storage_read(
+        evm.state_changes,
+        evm.message.current_target,
+        key,
+    )
+
     push(evm.stack, value)
 
     # PROGRAM COUNTER
@@ -94,19 +95,14 @@ def sstore(evm: Evm) -> None:
     # STACK
     key = pop(evm.stack).to_be_bytes32()
     new_value = pop(evm.stack)
-    if evm.gas_left <= GAS_CALL_STIPEND:
-        raise OutOfGasError
 
-    # Check static context before accessing storage
+    # check we have at least the stipend gas
+    check_gas(evm, GAS_CALL_STIPEND + Uint(1))
+
+    # check static context before accessing storage
     if evm.message.is_static:
         raise WriteInStaticContext
 
-    state = evm.message.block_env.state
-    original_value = get_storage_original(
-        state, evm.message.current_target, key
-    )
-    current_value = get_storage(state, evm.message.current_target, key)
-
     # GAS
     gas_cost = Uint(0)
     is_cold_access = (
@@ -117,16 +113,15 @@ def sstore(evm: Evm) -> None:
     if is_cold_access:
         gas_cost += GAS_COLD_SLOAD
 
-    if original_value == current_value and current_value != new_value:
-        if original_value == 0:
-            gas_cost += GAS_STORAGE_SET
-        else:
-            gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD
-    else:
-        gas_cost += GAS_WARM_ACCESS
+    state = evm.message.block_env.state
+    original_value = get_storage_original(
+        state, evm.message.current_target, key
+    )
+    current_value = get_storage(state, evm.message.current_target, key)
+
+    if is_cold_access:
+        evm.accessed_storage_keys.add((evm.message.current_target, key))
 
-    # Track storage access BEFORE checking gas (EIP-7928)
-    # Even if we run out of gas, the access attempt should be tracked
     capture_pre_storage(
         evm.message.tx_env.state_changes,
         evm.message.current_target,
@@ -138,10 +133,14 @@ def sstore(evm: Evm) -> None:
         evm.message.current_target,
         key,
     )
-    check_gas(evm, gas_cost)
 
-    if is_cold_access:
-        evm.accessed_storage_keys.add((evm.message.current_target, key))
+    if original_value == current_value and current_value != new_value:
+        if original_value == 0:
+            gas_cost += GAS_STORAGE_SET
+        else:
+            gas_cost += GAS_STORAGE_UPDATE - GAS_COLD_SLOAD
+    else:
+        gas_cost += GAS_WARM_ACCESS
 
     charge_gas(evm, gas_cost)
 

src/ethereum/forks/amsterdam/vm/instructions/system.py

@@ -130,7 +130,6 @@ def generic_create(
     if account_has_code_or_nonce(
         state, contract_address
     ) or account_has_storage(state, contract_address):
-        # Track nonce increment even on collision
         increment_nonce(state, evm.message.current_target)
         nonce_after = get_account(state, evm.message.current_target).nonce
         track_nonce_change(

src/ethereum/forks/amsterdam/vm/interpreter.py

@@ -145,8 +145,6 @@ def process_message_call(message: Message) -> MessageCallOutput:
             message.accessed_addresses.add(delegated_address)
             message.code = get_account(block_env.state, delegated_address).code
             message.code_address = delegated_address
-
-            # EIP-7928: Track delegation target when loaded as call target
             track_address(
                 message.block_env.block_state_changes, delegated_address
             )
@@ -215,7 +213,6 @@ def process_create_message(message: Message) -> Evm:
         message.block_env.block_state_changes
     )
 
-    # Track nonce increment for contract creation
     increment_nonce(state, message.current_target)
     nonce_after = get_account(state, message.current_target).nonce
     track_nonce_change(
@@ -284,6 +281,7 @@ def process_message(message: Message) -> Evm:
     if message.depth > STACK_DEPTH_LIMIT:
         raise StackDepthLimitError("Stack depth limit reached")
 
+    # take snapshot of state before processing the message
     begin_transaction(state, transient_storage)
 
     block_access_index = get_block_access_index(