TEMP:

prefer exceptions for base gas fee to None, where feasible
update mainnet block number for London
pass header sedes class in to APIs that used to assume a stable header spec, like when decoding block header uncles
	track header sedes in VM (unnecessary?), all_header_sedes
	infer sedes class of uncles from header that has the uncles

eth.db.chain.get_block_uncles API change
use new agnostic header deserializer when decoding unknown header bytes (eg~ look up hash by header)
increase default gas price in tests to 10 gwei to easily out-price the 1559 min gas fee of 1gwei
make old transactions understand max_priority_fee_per_gas and max_fee_per_gas (just return the gas_price, as the 1559 spec suggests)
validate the transaction nonce on new london transactions
enable creating a genesis London header (was hard-coded to pre-London-style)
	generally allow create_header_from_parent to accept a None parent, for genesis creation
use the correct VM's block header when creating a temp block for txn evaluation
Update tests that were configured with a gas price of < 1 gwei
Drop support for Header.from_parent which is essentially always wrong.
  Should use vm_class.create_header_from_parent instead.

Author: carver

eth/_utils/headers.py

@@ -7,18 +7,73 @@
 
 from eth.abc import BlockHeaderAPI
 from eth.constants import (
+    BLANK_ROOT_HASH,
+    EMPTY_UNCLE_HASH,
+    GENESIS_BLOCK_NUMBER,
     GENESIS_GAS_LIMIT,
+    GENESIS_NONCE,
+    GENESIS_PARENT_HASH,
     GAS_LIMIT_EMA_DENOMINATOR,
     GAS_LIMIT_ADJUSTMENT_FACTOR,
     GAS_LIMIT_MINIMUM,
     GAS_LIMIT_USAGE_ADJUSTMENT_NUMERATOR,
     GAS_LIMIT_USAGE_ADJUSTMENT_DENOMINATOR,
+    ZERO_ADDRESS,
+    ZERO_HASH32,
 )
 from eth.rlp.headers import (
     BlockHeader,
 )
 
 
+def fill_header_params_from_parent(
+        parent: BlockHeaderAPI,
+        gas_limit: int,
+        difficulty: int,
+        timestamp: int,
+        coinbase: Address = ZERO_ADDRESS,
+        nonce: bytes = None,
+        extra_data: bytes = None,
+        transaction_root: bytes = None,
+        state_root: bytes = None,
+        mix_hash: bytes = None,
+        receipt_root: bytes = None) -> 'BlockHeaderAPI':
+
+        if parent is None:
+            parent_hash = GENESIS_PARENT_HASH
+            block_number = GENESIS_BLOCK_NUMBER
+            if state_root is None:
+                raise ValueError(f"Must set state root on genesis block")
+        else:
+            parent_hash = parent.hash
+            block_number = parent.block_number + 1
+
+            if state_root is None:
+                state_root = parent.state_root
+
+        header_kwargs: Dict[str, HeaderParams] = {
+            'parent_hash': parent_hash,
+            'coinbase': coinbase,
+            'state_root': state_root,
+            'gas_limit': gas_limit,
+            'difficulty': difficulty,
+            'block_number': block_number,
+            'timestamp': timestamp,
+        }
+        if nonce is not None:
+            header_kwargs['nonce'] = nonce
+        if extra_data is not None:
+            header_kwargs['extra_data'] = extra_data
+        if transaction_root is not None:
+            header_kwargs['transaction_root'] = transaction_root
+        if receipt_root is not None:
+            header_kwargs['receipt_root'] = receipt_root
+        if mix_hash is not None:
+            header_kwargs['mix_hash'] = mix_hash
+
+        return header_kwargs
+
+
 def compute_gas_limit_bounds(parent: BlockHeaderAPI) -> Tuple[int, int]:
     """
     Compute the boundaries for the block gas limit based on the parent block.
@@ -29,7 +84,7 @@ def compute_gas_limit_bounds(parent: BlockHeaderAPI) -> Tuple[int, int]:
     return lower_bound, upper_bound
 
 
-def compute_gas_limit(parent_header: BlockHeaderAPI, gas_limit_floor: int) -> int:
+def compute_gas_limit(parent_header: BlockHeaderAPI, genesis_gas_limit: int) -> int:
     """
     A simple strategy for adjusting the gas limit.
 
@@ -38,21 +93,24 @@ def compute_gas_limit(parent_header: BlockHeaderAPI, gas_limit_floor: int) -> in
     - decrease by 1/1024th of the gas limit from the previous block
     - increase by 50% of the total gas used by the previous block
 
-    If the value is less than the given `gas_limit_floor`:
+    If the value is less than the given `genesis_gas_limit`:
 
     - increase the gas limit by 1/1024th of the gas limit from the previous block.
 
     If the value is less than the GAS_LIMIT_MINIMUM:
 
     - use the GAS_LIMIT_MINIMUM as the new gas limit.
     """
-    if gas_limit_floor < GAS_LIMIT_MINIMUM:
+    if genesis_gas_limit < GAS_LIMIT_MINIMUM:
         raise ValueError(
-            "The `gas_limit_floor` value must be greater than the "
-            f"GAS_LIMIT_MINIMUM.  Got {gas_limit_floor}.  Must be greater than "
+            "The `genesis_gas_limit` value must be greater than the "
+            f"GAS_LIMIT_MINIMUM.  Got {genesis_gas_limit}.  Must be greater than "
             f"{GAS_LIMIT_MINIMUM}"
         )
 
+    if parent_header is None:
+        return genesis_gas_limit
+
     decay = parent_header.gas_limit // GAS_LIMIT_EMA_DENOMINATOR
 
     if parent_header.gas_used:
@@ -73,40 +131,7 @@ def compute_gas_limit(parent_header: BlockHeaderAPI, gas_limit_floor: int) -> in
 
     if gas_limit < GAS_LIMIT_MINIMUM:
         return GAS_LIMIT_MINIMUM
-    elif gas_limit < gas_limit_floor:
+    elif gas_limit < genesis_gas_limit:
         return parent_header.gas_limit + decay
     else:
         return gas_limit
-
-
-def generate_header_from_parent_header(
-        compute_difficulty_fn: Callable[[BlockHeaderAPI, int], int],
-        parent_header: BlockHeaderAPI,
-        coinbase: Address,
-        timestamp: Optional[int] = None,
-        extra_data: bytes = b'') -> BlockHeader:
-    """
-    Generate BlockHeader from state_root and parent_header
-    """
-    if timestamp is None:
-        timestamp = max(int(time.time()), parent_header.timestamp + 1)
-    elif timestamp <= parent_header.timestamp:
-        raise ValueError(
-            f"header.timestamp ({timestamp}) should be higher than"
-            f"parent_header.timestamp ({parent_header.timestamp})"
-        )
-    header = BlockHeader(
-        difficulty=compute_difficulty_fn(parent_header, timestamp),
-        block_number=(parent_header.block_number + 1),
-        gas_limit=compute_gas_limit(
-            parent_header,
-            gas_limit_floor=GENESIS_GAS_LIMIT,
-        ),
-        timestamp=timestamp,
-        parent_hash=parent_header.hash,
-        state_root=parent_header.state_root,
-        coinbase=coinbase,
-        extra_data=extra_data,
-    )
-
-    return header

eth/abc.py

@@ -74,7 +74,7 @@ class MiningHeaderAPI(ABC):
     gas_used: int
     timestamp: int
     extra_data: bytes
-    base_fee_per_gas: int  # EIP-1559
+    base_fee_per_gas: int  # EIP-1559, set to None in pre-London header
 
     @property
     @abstractmethod
@@ -337,7 +337,10 @@ def nonce(self) -> int:
 
     @property
     @abstractmethod
-    def gas_price(self) -> Optional[int]:
+    def gas_price(self) -> int:
+        """
+        Will raise :cls:`AttributeError` if get or set on a 1559 transaction.
+        """
         ...
 
     @property
@@ -2877,8 +2880,9 @@ def get_computation(self,
     #
     # Transaction context
     #
+    @classmethod
     @abstractmethod
-    def get_transaction_context_class(self) -> Type[TransactionContextAPI]:
+    def get_transaction_context_class(cls) -> Type[TransactionContextAPI]:
         """
         Return the :class:`~eth.vm.transaction_context.BaseTransactionContext` class that the
         state class uses.
@@ -2990,6 +2994,36 @@ def get_fee_recipient(cls, header: BlockHeaderAPI) -> Address:
         ...
 
 
+
+class BlockHeaderSedesAPI(ABC):
+    """
+    Serialize and deserialize RLP for a header.
+
+    The header may be one of several definitions, like a London (EIP-1559) or
+    pre-London header.
+    """
+
+    @classmethod
+    @abstractmethod
+    def deserialize(cls, encoded: List[bytes]) -> BlockHeaderAPI:
+        """
+        Extract a header from an encoded RLP object.
+
+        This method is used by rlp.decode(..., sedes=TransactionBuilderAPI).
+        """
+        ...
+
+    @classmethod
+    @abstractmethod
+    def serialize(cls, obj: BlockHeaderAPI) -> List[bytes]:
+        """
+        Encode a header to a series of bytes used by RLP.
+
+        This method is used by rlp.encode(obj).
+        """
+        ...
+
+
 class VirtualMachineAPI(ConfigurableAPI):
     """
     The :class:`~eth.abc.VirtualMachineAPI` class represents the Chain rules for a
@@ -3008,6 +3042,7 @@ class VirtualMachineAPI(ConfigurableAPI):
     extra_data_max_bytes: ClassVar[int]
     consensus_class: Type[ConsensusAPI]
     consensus_context: ConsensusContextAPI
+    all_header_sedes: ClassVar[Type[BlockHeaderSedesAPI]]
 
     @abstractmethod
     def __init__(self,

eth/chains/base.py

@@ -22,6 +22,7 @@
 )
 from eth_utils.toolz import (
     concatv,
+    keyfilter,
     sliding_window,
 )
 
@@ -249,7 +250,7 @@ def from_genesis(cls,
                 f"Expected {genesis_params['state_root']!r}"
             )
 
-        genesis_header = BlockHeader(**genesis_params)
+        genesis_header = genesis_vm_class.create_header_from_parent(None, **genesis_params)
         return cls.from_genesis_header(base_db, genesis_header)
 
     @classmethod
@@ -497,6 +498,7 @@ def persist_block(
         if perform_validation:
             self.validate_block(block)
 
+        vm = self.get_vm(block.header)
         (
             new_canonical_hashes,
             old_canonical_hashes,

eth/chains/mainnet/constants.py

@@ -58,8 +58,7 @@
 #
 BERLIN_MAINNET_BLOCK = BlockNumber(12244000)
 
-
 #
 # London Block
 #
-LONDON_MAINNET_BLOCK = BlockNumber(12244001)  # TODO change to actual when known
+LONDON_MAINNET_BLOCK = BlockNumber(12965000)

eth/db/chain.py

@@ -25,6 +25,7 @@
 from eth.abc import (
     BlockAPI,
     BlockHeaderAPI,
+    BlockHeaderSedesAPI,
     ChainDatabaseAPI,
     DatabaseAPI,
     AtomicDatabaseAPI,
@@ -154,7 +155,8 @@ def _update_header_chain_gaps(
     #
     # Header API
     #
-    def get_block_uncles(self, uncles_hash: Hash32) -> Tuple[BlockHeaderAPI, ...]:
+    def get_block_uncles(self, niece_header: BlockHeader) -> Tuple[BlockHeaderAPI, ...]:
+        uncles_hash = niece_header.uncles_hash
         validate_word(uncles_hash, title="Uncles Hash")
         if uncles_hash == EMPTY_UNCLE_HASH:
             return ()
@@ -165,7 +167,8 @@ def get_block_uncles(self, uncles_hash: Hash32) -> Tuple[BlockHeaderAPI, ...]:
                 f"No uncles found for hash {uncles_hash!r}"
             ) from exc
         else:
-            return tuple(rlp.decode(encoded_uncles, sedes=rlp.sedes.CountableList(BlockHeader)))
+            header_sedes = niece_header
+            return tuple(rlp.decode(encoded_uncles, sedes=rlp.sedes.CountableList(header_sedes)))
 
     @classmethod
     def _decanonicalize_old_headers(
@@ -261,7 +264,7 @@ def _persist_block(
                 cls._add_transaction_to_canonical_chain(db, transaction_hash, header, index)
 
         if block.uncles:
-            uncles_hash = cls._persist_uncles(db, block.uncles)
+            uncles_hash = cls._persist_uncles(db, block.uncles, block.header)
         else:
             uncles_hash = EMPTY_UNCLE_HASH
         if uncles_hash != block.header.uncles_hash:
@@ -275,15 +278,22 @@ def _persist_block(
         cls._update_chain_gaps(db, block)
         return new_canonical_hashes, old_canonical_hashes
 
-    def persist_uncles(self, uncles: Tuple[BlockHeaderAPI]) -> Hash32:
-        return self._persist_uncles(self.db, uncles)
+    def persist_uncles(
+            self,
+            uncles: Tuple[BlockHeaderAPI],
+            header_sedes: BlockHeaderSedesAPI) -> Hash32:
+        return self._persist_uncles(self.db, uncles, header_sedes)
 
     @staticmethod
-    def _persist_uncles(db: DatabaseAPI, uncles: Tuple[BlockHeaderAPI, ...]) -> Hash32:
+    def _persist_uncles(
+            db: DatabaseAPI,
+            uncles: Tuple[BlockHeaderAPI, ...],
+            header_sedes: BlockHeaderSedesAPI) -> Hash32:
+
         uncles_hash = keccak(rlp.encode(uncles))
         db.set(
             uncles_hash,
-            rlp.encode(uncles, sedes=rlp.sedes.CountableList(BlockHeader)))
+            rlp.encode(uncles, sedes=rlp.sedes.CountableList(header_sedes)))
         return uncles_hash
 
     #

eth/db/header.py

@@ -56,8 +56,8 @@
     validate_block_number,
     validate_word,
 )
-from eth.vm.forks.london.blocks import (
-    LondonBlockHeader
+from eth.vm.forks.london.headers import (
+    LondonBackwardsHeader,
 )
 
 from rlp.exceptions import (
@@ -625,8 +625,10 @@ def _add_block_number_to_hash_lookup(db: DatabaseAPI, header: BlockHeaderAPI) ->
 # be looking up recent blocks.
 @functools.lru_cache(128)
 def _decode_block_header(header_rlp: bytes) -> BlockHeaderAPI:
-    try:
-        return rlp.decode(header_rlp, sedes=BlockHeader)
-    except ObjectDeserializationError:
-        # could be a new >=London block header
-        return rlp.decode(header_rlp, sedes=LondonBlockHeader)
+    # Use a deserialization class that can handle any type of header.
+    # This feels a little hack-y, but we don't know the shape of the header
+    # at this point. It could be a pre-London header, or a post-London
+    # header, which includes the base fee. So we use a class that simply
+    # checks both. Ideally, it will try London first, since all new headers will
+    # be valid for London (until the next fork that breaks it).
+    return rlp.decode(header_rlp, sedes=LondonBackwardsHeader)

eth/estimators/gas.py

@@ -63,6 +63,7 @@ def binary_gas_search(state: StateAPI,
     maximum_transaction = cast(SignedTransactionAPI, SpoofTransaction(
         transaction,
         gas=state.gas_limit,
+        # TODO EIP-1559 update
         gas_price=0,
     ))
     error = _get_computation_error(state, maximum_transaction)