Test and fix base fee adjustment

1. target is half of limit
2. gas_used_delta bug when parent_gas_used > parent_gas_target: was
subtracting base fee instead of target

Author: carver

eth/vm/forks/london/headers.py

@@ -42,27 +42,30 @@ def calculate_expected_base_fee_per_gas(parent_header: BlockHeaderAPI) -> int:
             # Parent is a non-London header
             return INITIAL_BASE_FEE
 
-    parent_gas_target = parent_header.gas_limit
+    # Parent *is* a London header
+    parent_gas_target = parent_header.gas_limit // ELASTICITY_MULTIPLIER
     parent_gas_used = parent_header.gas_used
 
     if parent_gas_used == parent_gas_target:
         return parent_base_fee_per_gas
 
     elif parent_gas_used > parent_gas_target:
-        gas_used_delta = parent_gas_used - parent_base_fee_per_gas
+        gas_used_delta = parent_gas_used - parent_gas_target
+        overburnt_wei = parent_base_fee_per_gas * gas_used_delta
         base_fee_per_gas_delta = max(
-            (
-                parent_base_fee_per_gas * gas_used_delta
-                // parent_gas_target // BASE_FEE_MAX_CHANGE_DENOMINATOR
-            ),
-            1
+            overburnt_wei // parent_gas_target // BASE_FEE_MAX_CHANGE_DENOMINATOR,
+            1,
         )
         return parent_base_fee_per_gas + base_fee_per_gas_delta
 
     else:
         gas_used_delta = parent_gas_target - parent_gas_used
-        base_fee_per_gas_delta = parent_base_fee_per_gas * gas_used_delta \
-            // parent_gas_target // BASE_FEE_MAX_CHANGE_DENOMINATOR
+        underburnt_wei = parent_base_fee_per_gas * gas_used_delta
+        base_fee_per_gas_delta = (
+            underburnt_wei
+            // parent_gas_target
+            // BASE_FEE_MAX_CHANGE_DENOMINATOR
+        )
         return max(parent_base_fee_per_gas - base_fee_per_gas_delta, 0)
 
 

tests/core/vm/test_london.py

@@ -0,0 +1,80 @@
+import pytest
+
+from eth import constants
+from eth.consensus.noproof import NoProofConsensus
+from eth.chains.base import MiningChain
+from eth.chains.mainnet import (
+    MAINNET_VMS,
+)
+from eth.vm.forks import BerlinVM
+from eth.tools.factories.transaction import (
+    new_transaction
+)
+
+
+# VMs starting at London
+@pytest.fixture(params=MAINNET_VMS[9:])
+def london_plus_miner(request, base_db, genesis_state):
+    klass = MiningChain.configure(
+        __name__='CrossoverTestChain',
+        vm_configuration=(
+            (
+                constants.GENESIS_BLOCK_NUMBER,
+                BerlinVM.configure(consensus_class=NoProofConsensus),
+            ),
+            (
+                constants.GENESIS_BLOCK_NUMBER + 1,
+                request.param.configure(consensus_class=NoProofConsensus),
+            ),
+        ),
+        chain_id=1337,
+    )
+    header_fields = dict(
+        difficulty=1,
+        gas_limit=21000 * 2,  # block limit is hit with two transactions
+    )
+    # On the first London+ block, it will double the block limit so that the
+    #   block *target* is hit with 2 transactions
+    return klass.from_genesis(base_db, header_fields, genesis_state)
+
+
+@pytest.mark.parametrize(
+    'num_txns, expected_base_fee',
+    (
+        (0, 875000000),
+        (1, 937500000),
+        # base fee should stay stable at 1 gwei when block is exactly half full
+        (2, 1000000000),
+        (3, 1062500000),
+        (4, 1125000000),
+    ),
+)
+def test_base_fee_evolution(
+        london_plus_miner, funded_address, funded_address_private_key, num_txns, expected_base_fee):
+    chain = london_plus_miner
+    assert chain.header.gas_limit == 21000 * 4
+
+    vm = chain.get_vm()
+    txns = [
+        new_transaction(
+            vm,
+            funded_address,
+            b'\x00' * 20,
+            private_key=funded_address_private_key,
+            gas=21000,
+            nonce=nonce,
+        )
+        for nonce in range(num_txns)
+    ]
+    block_import, _, _ = chain.mine_all(txns, gas_limit=21000 * 4)
+    mined_header = block_import.imported_block.header
+    assert mined_header.gas_limit == 21000 * 4
+    assert mined_header.gas_used == 21000 * num_txns
+    assert mined_header.base_fee_per_gas == 10 ** 9  # Initialize at 1 gwei
+
+    # Next block should have an unchanged gas fee because usage was equal to target (half of limit)
+    block_import, _, _ = chain.mine_all([], gas_limit=21000 * 4)
+    mined_header = block_import.imported_block.header
+    assert mined_header.gas_limit == 21000 * 4
+    assert mined_header.gas_used == 0
+    assert mined_header.base_fee_per_gas == expected_base_fee