Validate London txn gas costs, plus tests

- Test London validation of sender sufficient funds

Author: carver

eth/tools/factories/transaction.py

@@ -77,3 +77,42 @@ def new_access_list_transaction(
     )
 
     return tx.as_signed_transaction(private_key)
+
+
+@curry
+def new_fee_burn_transaction(
+        vm,
+        from_,
+        to,
+        private_key,
+        amount=0,
+        max_priority_fee_per_gas=1,
+        max_fee_per_gas=10**10,
+        gas=100000,
+        data=b'',
+        nonce=None,
+        chain_id=1,
+        access_list=None):
+    """
+    Create and return a transaction sending amount from <from_> to <to>.
+
+    The transaction will be signed with the given private key.
+    """
+    if nonce is None:
+        nonce = vm.state.get_nonce(from_)
+    if access_list is None:
+        access_list = []
+
+    tx = vm.get_transaction_builder().new_unsigned_fee_burn_transaction(
+        chain_id=chain_id,
+        nonce=nonce,
+        max_priority_fee_per_gas=max_priority_fee_per_gas,
+        max_fee_per_gas=max_fee_per_gas,
+        gas=gas,
+        to=to,
+        value=amount,
+        data=data,
+        access_list=access_list,
+    )
+
+    return tx.as_signed_transaction(private_key)

eth/vm/forks/london/transactions.py

@@ -224,7 +224,7 @@ class LondonTransactionBuilder(BerlinTransactionBuilder):
     legacy_unsigned = LondonUnsignedLegacyTransaction
 
     @classmethod
-    def new_unsigned_base_gas_price_transaction(
+    def new_unsigned_fee_burn_transaction(
             cls,
             chain_id: int,
             nonce: int,
@@ -249,7 +249,7 @@ def new_unsigned_base_gas_price_transaction(
         return transaction
 
     @classmethod
-    def new_base_gas_price_transaction(
+    def new_fee_burn_transaction(
             cls,
             chain_id: int,
             nonce: int,

eth/vm/forks/london/validation.py

@@ -38,7 +38,7 @@ def validate_london_normalized_transaction(
     )
 
     effective_gas_price = priority_fee_per_gas + base_fee_per_gas
-    total_transaction_cost = transaction.value + effective_gas_price
+    total_transaction_cost = transaction.value + effective_gas_price * transaction.gas
 
     if sender_balance < total_transaction_cost:
         raise ValidationError(

tests/core/vm/test_validate_transaction.py

@@ -0,0 +1,90 @@
+from eth_utils import ValidationError
+import pytest
+
+from eth._utils.address import force_bytes_to_address
+from eth.chains.base import MiningChain
+from eth.constants import GAS_TX
+from eth.tools.factories.transaction import new_fee_burn_transaction
+from eth.vm.forks import LondonVM
+
+
+@pytest.fixture
+def london_plus_miner(chain_without_block_validation):
+    if not isinstance(chain_without_block_validation, MiningChain):
+        pytest.skip("This test is only meant to run with mining capability")
+        return
+
+    valid_vms = (
+        LondonVM,
+    )
+    vm = chain_without_block_validation.get_vm()
+    if isinstance(vm, valid_vms):
+        return chain_without_block_validation
+    else:
+        pytest.skip("This test is not meant to run on pre-London VMs")
+
+
+ADDRESS_A = force_bytes_to_address(b'\x10\x10')
+
+
+def test_transaction_cost_valid(london_plus_miner, funded_address, funded_address_private_key):
+    chain = london_plus_miner
+    vm = chain.get_vm()
+    base_fee_per_gas = vm.get_header().base_fee_per_gas
+    # Make sure we're testing an interesting case
+    assert base_fee_per_gas > 0
+
+    account_balance = vm.state.get_balance(funded_address)
+
+    tx = new_fee_burn_transaction(
+        vm,
+        from_=funded_address,
+        to=ADDRESS_A,
+        private_key=funded_address_private_key,
+        gas=GAS_TX,
+        amount=account_balance - base_fee_per_gas * GAS_TX,
+        max_priority_fee_per_gas=1,
+        max_fee_per_gas=base_fee_per_gas,
+    )
+
+    # sanity check
+    assert vm.get_header().gas_used == 0
+
+    # There should be no validation failure when applying the transaction
+    chain.apply_transaction(tx)
+
+    # sanity check: make sure the transaction actually got applied
+    assert chain.get_vm().get_header().gas_used > 0
+
+
+def test_transaction_cost_invalid(london_plus_miner, funded_address, funded_address_private_key):
+    chain = london_plus_miner
+    vm = chain.get_vm()
+    base_fee_per_gas = vm.get_header().base_fee_per_gas
+    # Make sure we're testing an interesting case
+    assert base_fee_per_gas > 0
+
+    account_balance = vm.state.get_balance(funded_address)
+
+    tx = new_fee_burn_transaction(
+        vm,
+        from_=funded_address,
+        to=ADDRESS_A,
+        private_key=funded_address_private_key,
+        gas=GAS_TX,
+        amount=account_balance - base_fee_per_gas * GAS_TX + 1,
+        max_priority_fee_per_gas=1,
+        max_fee_per_gas=base_fee_per_gas,
+    )
+
+    # sanity check
+    assert vm.get_header().gas_used == 0
+
+    # The *validation* step should catch that the sender does not have enough funds. If validation
+    # misses the problem, then we might see an InsufficientFunds, because the VM will think the
+    # transaction is fine, then attempt to execute it, then then run out of funds.
+    with pytest.raises(ValidationError):
+        chain.apply_transaction(tx)
+
+    # sanity check: make sure the transaction does not get applied
+    assert chain.get_vm().get_header().gas_used == 0