fixup

Author: SamWilsn

src/ethereum/prague/blocks.py

@@ -9,12 +9,16 @@
 chain.
 """
 from dataclasses import dataclass
-from typing import Tuple, Union
+from typing import Annotated, Optional, Tuple, Union
 
 from ethereum_rlp import rlp
 from ethereum_types.bytes import Bytes, Bytes8, Bytes32
 from ethereum_types.frozen import slotted_freezable
 from ethereum_types.numeric import U64, U256, Uint
+from typing_extensions import TypeAlias
+
+from ethereum.cancun import blocks as previous_blocks
+from ethereum.exceptions import InvalidBlock
 
 from ..crypto.hash import Hash32
 from .fork_types import Address, Bloom, Root
@@ -71,6 +75,49 @@ class Header:
     requests_hash: Hash32
 
 
+AnyHeader: TypeAlias = Union[previous_blocks.AnyHeader, Header]
+"""
+Represents all headers that may have appeared in the blockchain before or in
+the current fork.
+"""
+
+
+def decode_header(raw_header: rlp.Simple) -> AnyHeader:
+    """
+    Convert `raw_header` from raw sequences and bytes to a structured block
+    header.
+
+    Checks `raw_header` against this fork's `FORK_CRITERIA`, and if it belongs
+    to this fork, decodes it accordingly. If not, this function forwards to the
+    preceding fork where the process is repeated.
+    """
+    from . import FORK_CRITERIA
+
+    # First, ensure that `raw_header` is not `bytes` (and is therefore a
+    # sequence.)
+    if isinstance(raw_header, bytes):
+        raise InvalidBlock("header is bytes, expected sequence")
+
+    # Next, extract the block number and timestamp (which are always at index 8
+    # and 11 respectively.)
+    raw_number = raw_header[8]
+    if not isinstance(raw_number, bytes):
+        raise InvalidBlock("header number is sequence, expected bytes")
+    number = Uint.from_be_bytes(raw_number)
+
+    raw_timestamp = raw_header[11]
+    if not isinstance(raw_timestamp, bytes):
+        raise InvalidBlock("header timestamp is sequence, expected bytes")
+    timestamp = U256.from_be_bytes(raw_timestamp)
+
+    # Finally, check if this header belongs to this fork.
+    if FORK_CRITERIA.check(number, timestamp):
+        return rlp.deserialize_to(Header, raw_header)
+
+    # If it doesn't, forward to the preceding fork.
+    return previous_blocks.decode_header(raw_header)
+
+
 @slotted_freezable
 @dataclass
 class Block:
@@ -80,10 +127,17 @@ class Block:
 
     header: Header
     transactions: Tuple[Union[Bytes, LegacyTransaction], ...]
-    ommers: Tuple[Header, ...]
+    ommers: Tuple[Annotated[AnyHeader, rlp.With(decode_header)], ...]
     withdrawals: Tuple[Withdrawal, ...]
 
 
+AnyBlock: TypeAlias = Union[previous_blocks.AnyBlock, Block]
+"""
+Represents all blocks that may have appeared in the blockchain before or in the
+current fork.
+"""
+
+
 @slotted_freezable
 @dataclass
 class Log:
@@ -134,3 +188,13 @@ def decode_receipt(receipt: Union[Bytes, Receipt]) -> Receipt:
         return rlp.decode_to(Receipt, receipt[1:])
     else:
         return receipt
+
+
+def header_base_fee_per_gas(header: AnyHeader) -> Optional[Uint]:
+    """
+    Returns the `base_fee_per_gas` of the given header, or `None` for headers
+    without that field.
+    """
+    if isinstance(header, Header):
+        return header.base_fee_per_gas
+    return previous_blocks.header_base_fee_per_gas(header)

src/ethereum/prague/fork.py

@@ -19,6 +19,7 @@
 from ethereum_types.bytes import Bytes
 from ethereum_types.numeric import U64, U256, Uint
 
+from ethereum.cancun import fork as previous_fork
 from ethereum.crypto.hash import Hash32, keccak256
 from ethereum.exceptions import (
     EthereumException,
@@ -27,7 +28,17 @@
 )
 
 from . import vm
-from .blocks import Block, Header, Log, Receipt, Withdrawal, encode_receipt
+from .blocks import (
+    AnyBlock,
+    AnyHeader,
+    Block,
+    Header,
+    Log,
+    Receipt,
+    Withdrawal,
+    encode_receipt,
+    header_base_fee_per_gas,
+)
 from .bloom import logs_bloom
 from .fork_types import Account, Address, Authorization, VersionedHash
 from .requests import (
@@ -79,6 +90,7 @@
 ELASTICITY_MULTIPLIER = Uint(2)
 GAS_LIMIT_ADJUSTMENT_FACTOR = Uint(1024)
 GAS_LIMIT_MINIMUM = Uint(5000)
+INITIAL_BASE_FEE = Uint(1000000000)
 EMPTY_OMMER_HASH = keccak256(rlp.encode([]))
 SYSTEM_ADDRESS = hex_to_address("0xfffffffffffffffffffffffffffffffffffffffe")
 BEACON_ROOTS_ADDRESS = hex_to_address(
@@ -106,7 +118,7 @@ class BlockChain:
     History and current state of the block chain.
     """
 
-    blocks: List[Block]
+    blocks: List[AnyBlock]
     state: State
     chain_id: U64
 
@@ -313,7 +325,7 @@ def calculate_base_fee_per_gas(
     return Uint(expected_base_fee_per_gas)
 
 
-def validate_header(chain: BlockChain, header: Header) -> None:
+def validate_header(chain: BlockChain, header: AnyHeader) -> None:
     """
     Verifies a block header.
 
@@ -351,15 +363,25 @@ def validate_header(chain: BlockChain, header: Header) -> None:
     if header.excess_blob_gas != excess_blob_gas:
         raise InvalidBlock
 
+    if not isinstance(header, Header):
+        assert not isinstance(parent_header, Header)
+        return previous_fork.validate_header(chain, header)
+
     if header.gas_used > header.gas_limit:
         raise InvalidBlock
 
-    expected_base_fee_per_gas = calculate_base_fee_per_gas(
-        header.gas_limit,
-        parent_header.gas_limit,
-        parent_header.gas_used,
-        parent_header.base_fee_per_gas,
-    )
+    expected_base_fee_per_gas = INITIAL_BASE_FEE
+    parent_base_fee_per_gas = header_base_fee_per_gas(parent_header)
+    if parent_base_fee_per_gas is not None:
+        # For every block except the first, calculate the base fee per gas
+        # based on the parent block.
+        expected_base_fee_per_gas = calculate_base_fee_per_gas(
+            header.gas_limit,
+            parent_header.gas_limit,
+            parent_header.gas_used,
+            parent_base_fee_per_gas,
+        )
+
     if expected_base_fee_per_gas != header.base_fee_per_gas:
         raise InvalidBlock
     if header.timestamp <= parent_header.timestamp:

src/ethereum/prague/vm/gas.py

@@ -19,7 +19,7 @@
 from ethereum.trace import GasAndRefund, evm_trace
 from ethereum.utils.numeric import ceil32, taylor_exponential
 
-from ..blocks import Header
+from ..blocks import AnyHeader, Header
 from ..transactions import BlobTransaction, Transaction
 from . import Evm
 from .exceptions import OutOfGasError
@@ -276,7 +276,7 @@ def init_code_cost(init_code_length: Uint) -> Uint:
     return GAS_INIT_CODE_WORD_COST * ceil32(init_code_length) // Uint(32)
 
 
-def calculate_excess_blob_gas(parent_header: Header) -> U64:
+def calculate_excess_blob_gas(parent_header: AnyHeader) -> U64:
     """
     Calculated the excess blob gas for the current block based
     on the gas used in the parent block.

tests/prague/test_rlp.py

@@ -94,7 +94,7 @@
     receipt_root=hash5,
     bloom=bloom,
     difficulty=Uint(1),
-    number=Uint(2),
+    number=Uint(19426587),
     gas_limit=Uint(3),
     gas_used=Uint(4),
     timestamp=U256(5),