Implement more of EIP-1559

- prefer exceptions for base gas fee to None, where feasible
- update mainnet block number for London
- 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.
- Make eth_call free again
  - when running a call, set the header's base gas fee to 0
  - API update: state_in_temp_block -> in_costless_state to reference ^
- Correctly load uncles across fork boundary
  - Add test to validate uncles across chain VMs
  - Use a universal header sedes, since we can't load the VM before decoding the header
  - Decode block bodies with both London and pre-London uncles
  - Bonus bugfix: must double the header's gas limit at the VM boundary
- Implement base fee adjustment, with tests
  - target must be half of limit
  - gas_used_delta bug when parent_gas_used > parent_gas_target: was
    subtracting base fee instead of target
- Apply gas limit rules correctly
    Note that the 'diff' approach had a bug when 'diff' was negative. That
    approach needed a math.abs() to correctly validate the limit.

Author: carver

eth/_utils/headers.py

@@ -7,29 +7,85 @@
 
 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_MAXIMUM,
     GAS_LIMIT_MINIMUM,
     GAS_LIMIT_USAGE_ADJUSTMENT_NUMERATOR,
     GAS_LIMIT_USAGE_ADJUSTMENT_DENOMINATOR,
+    ZERO_ADDRESS,
+    ZERO_HASH32,
 )
 from eth.rlp.headers import (
     BlockHeader,
 )
 
 
-def compute_gas_limit_bounds(parent: BlockHeaderAPI) -> Tuple[int, int]:
+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(previous_limit: int) -> Tuple[int, int]:
     """
     Compute the boundaries for the block gas limit based on the parent block.
     """
-    boundary_range = parent.gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
-    upper_bound = parent.gas_limit + boundary_range
-    lower_bound = max(GAS_LIMIT_MINIMUM, parent.gas_limit - boundary_range)
+    boundary_range = previous_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
+    upper_bound = min(GAS_LIMIT_MAXIMUM, previous_limit + boundary_range)
+    lower_bound = max(GAS_LIMIT_MINIMUM, previous_limit - boundary_range)
     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 +94,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 +132,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
@@ -1690,9 +1693,9 @@ def chain_id(self) -> int:
 
     @property
     @abstractmethod
-    def base_gas_fee(self) -> Optional[int]:
+    def base_fee_per_gas(self) -> Optional[int]:
         """
-        Return the base gas fee of the block
+        Return the base fee per gas of the block
         """
         ...
 
@@ -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
@@ -3466,10 +3500,10 @@ def get_state_class(cls) -> Type[StateAPI]:
         ...
 
     @abstractmethod
-    def state_in_temp_block(self) -> ContextManager[StateAPI]:
+    def in_costless_state(self) -> ContextManager[StateAPI]:
         """
         Return a :class:`~typing.ContextManager` with the current state wrapped in a temporary
-        block.
+        block. In this state, the ability to pay gas costs is ignored.
         """
         ...
 
@@ -3932,13 +3966,6 @@ def validate_seal(self, header: BlockHeaderAPI) -> None:
         """
         ...
 
-    @abstractmethod
-    def validate_gaslimit(self, header: BlockHeaderAPI) -> None:
-        """
-        Validate the gas limit on the given ``header``.
-        """
-        ...
-
     @abstractmethod
     def validate_uncles(self, block: BlockAPI) -> None:
         """

eth/chains/base.py

@@ -22,6 +22,7 @@
 )
 from eth_utils.toolz import (
     concatv,
+    keyfilter,
     sliding_window,
 )
 
@@ -31,9 +32,6 @@
 from eth._utils.datatypes import (
     Configurable,
 )
-from eth._utils.headers import (
-    compute_gas_limit_bounds,
-)
 from eth._utils.rlp import (
     validate_imported_block_unchanged,
 )
@@ -249,7 +247,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
@@ -442,7 +440,7 @@ def get_transaction_result(
             transaction: SignedTransactionAPI,
             at_header: BlockHeaderAPI) -> bytes:
 
-        with self.get_vm(at_header).state_in_temp_block() as state:
+        with self.get_vm(at_header).in_costless_state() as state:
             computation = state.costless_execute_transaction(transaction)
 
         computation.raise_if_error()
@@ -454,7 +452,7 @@ def estimate_gas(
             at_header: BlockHeaderAPI = None) -> int:
         if at_header is None:
             at_header = self.get_canonical_head()
-        with self.get_vm(at_header).state_in_temp_block() as state:
+        with self.get_vm(at_header).in_costless_state() as state:
             return self.gas_estimator(state, transaction)
 
     def import_block(self,
@@ -497,6 +495,7 @@ def persist_block(
         if perform_validation:
             self.validate_block(block)
 
+        vm = self.get_vm(block.header)
         (
             new_canonical_hashes,
             old_canonical_hashes,
@@ -541,28 +540,11 @@ def validate_block(self, block: BlockAPI) -> None:
         vm.validate_seal(block.header)
         vm.validate_seal_extension(block.header, ())
         self.validate_uncles(block)
-        self.validate_gaslimit(block.header)
 
     def validate_seal(self, header: BlockHeaderAPI) -> None:
         vm = self.get_vm(header)
         vm.validate_seal(header)
 
-    def validate_gaslimit(self, header: BlockHeaderAPI) -> None:
-        parent_header = self.get_block_header_by_hash(header.parent_hash)
-        low_bound, high_bound = compute_gas_limit_bounds(parent_header)
-        if header.gas_limit < low_bound:
-            raise ValidationError(
-                f"The gas limit on block {encode_hex(header.hash)} "
-                f"is too low: {header.gas_limit}. "
-                f"It must be at least {low_bound}"
-            )
-        elif header.gas_limit > high_bound:
-            raise ValidationError(
-                f"The gas limit on block {encode_hex(header.hash)} "
-                f"is too high: {header.gas_limit}. "
-                f"It must be at most {high_bound}"
-            )
-
     def validate_uncles(self, block: BlockAPI) -> None:
         has_uncles = len(block.uncles) > 0
         should_have_uncles = block.header.uncles_hash != EMPTY_UNCLE_HASH

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)