Calculate miner tip correctly for EIP-1559

- add tests to verify
- Push backwards-compatible usages of get_tip() to Frontier
- Bonus fix: setting coinbase when mining
  The coinbase address was not correctly receiving transaction fees when
  the address is passed as a kwarg to MiningChain.mine_all or .mine_block
- Bonus fix: Correctly decode dynamic-fee txns in London

Author: carver

eth/abc.py

@@ -2679,6 +2679,18 @@ def get_gas_price(self, transaction: SignedTransactionAPI) -> int:
         """
         ...
 
+    @abstractmethod
+    def get_tip(self, transaction: SignedTransactionAPI) -> int:
+        """
+        Return the gas price that gets allocated to the miner/validator.
+
+        Pre-EIP-1559 that would be the full transaction gas price. After, it
+        would be the tip price (potentially reduced, if the base fee is so high
+        that it surpasses the transaction's maximum gas price after adding the
+        tip).
+        """
+        ...
+
     #
     # Access to account db
     #

eth/chains/base.py

@@ -663,6 +663,12 @@ def import_block(self,
     def set_header_timestamp(self, timestamp: int) -> None:
         self.header = self.header.copy(timestamp=timestamp)
 
+    @staticmethod
+    def _custom_header(base_header: BlockHeaderAPI, **kwargs: Any) -> BlockHeaderAPI:
+        header_fields = {'coinbase'}
+        header_params = {k: v for k, v in kwargs.items() if k in header_fields}
+        return base_header.copy(**header_params)
+
     def mine_all(
             self,
             transactions: Sequence[SignedTransactionAPI],
@@ -676,7 +682,8 @@ def mine_all(
         else:
             base_header = self.create_header_from_parent(parent_header)
 
-        vm = self.get_vm(base_header)
+        custom_header = self._custom_header(base_header, **kwargs)
+        vm = self.get_vm(custom_header)
 
         new_header, receipts, computations = vm.apply_all_transactions(transactions, base_header)
         filled_block = vm.set_block_transactions(vm.get_block(), new_header, transactions, receipts)
@@ -697,7 +704,8 @@ def mine_block(self, *args: Any, **kwargs: Any) -> BlockAPI:
         return self.mine_block_extended(*args, **kwargs).block
 
     def mine_block_extended(self, *args: Any, **kwargs: Any) -> BlockAndMetaWitness:
-        vm = self.get_vm(self.header)
+        custom_header = self._custom_header(self.header, **kwargs)
+        vm = self.get_vm(custom_header)
         current_block = vm.get_block()
         mine_result = vm.mine_block(current_block, *args, **kwargs)
         mined_block = mine_result.block

eth/vm/forks/berlin/transactions.py

@@ -388,6 +388,7 @@ class BerlinTransactionBuilder(TransactionBuilderAPI):
     """
     legacy_signed = BerlinLegacyTransaction
     legacy_unsigned = BerlinUnsignedLegacyTransaction
+    typed_transaction = TypedTransaction
 
     @classmethod
     def decode(cls, encoded: bytes) -> SignedTransactionAPI:
@@ -396,21 +397,21 @@ def decode(cls, encoded: bytes) -> SignedTransactionAPI:
 
         type_id = to_int(encoded[0])
         if type_id in VALID_TRANSACTION_TYPES:
-            return TypedTransaction.decode(encoded)
+            return cls.typed_transaction.decode(encoded)
         else:
             return rlp.decode(encoded, sedes=cls.legacy_signed)
 
     @classmethod
     def deserialize(cls, encoded: DecodedZeroOrOneLayerRLP) -> SignedTransactionAPI:
         if isinstance(encoded, bytes):
-            return TypedTransaction.deserialize(encoded)
+            return cls.typed_transaction.deserialize(encoded)
         else:
             return cls.legacy_signed.deserialize(encoded)
 
     @classmethod
     def serialize(cls, obj: SignedTransactionAPI) -> DecodedZeroOrOneLayerRLP:
-        if isinstance(obj, TypedTransaction):
-            return TypedTransaction.serialize(obj)
+        if isinstance(obj, cls.typed_transaction):
+            return cls.typed_transaction.serialize(obj)
         else:
             return cls.legacy_signed.serialize(obj)
 
@@ -489,4 +490,4 @@ def new_access_list_transaction(
             r,
             s,
         )
-        return TypedTransaction(ACCESS_LIST_TRANSACTION_TYPE, transaction)
+        return cls.typed_transaction(ACCESS_LIST_TRANSACTION_TYPE, transaction)

eth/vm/forks/frontier/state.py

@@ -145,6 +145,8 @@ def build_computation(self,
     def finalize_computation(self,
                              transaction: SignedTransactionAPI,
                              computation: ComputationAPI) -> ComputationAPI:
+        transaction_context = self.vm_state.get_transaction_context(transaction)
+
         # Self Destruct Refunds
         num_deletions = len(computation.get_accounts_for_deletion())
         if num_deletions:
@@ -155,7 +157,7 @@ def finalize_computation(self,
         gas_refunded = computation.get_gas_refund()
         gas_used = transaction.gas - gas_remaining
         gas_refund = min(gas_refunded, gas_used // 2)
-        gas_refund_amount = (gas_refund + gas_remaining) * transaction.gas_price
+        gas_refund_amount = (gas_refund + gas_remaining) * transaction_context.gas_price
 
         if gas_refund_amount:
             self.vm_state.logger.debug2(
@@ -167,8 +169,8 @@ def finalize_computation(self,
             self.vm_state.delta_balance(computation.msg.sender, gas_refund_amount)
 
         # Miner Fees
-        transaction_fee = \
-            (transaction.gas - gas_remaining - gas_refund) * transaction.gas_price
+        gas_used = transaction.gas - gas_remaining - gas_refund
+        transaction_fee = gas_used * self.vm_state.get_tip(transaction)
         self.vm_state.logger.debug2(
             'TRANSACTION FEE: %s -> %s',
             transaction_fee,

eth/vm/forks/frontier/validation.py

@@ -12,19 +12,22 @@
 
 def validate_frontier_transaction(state: StateAPI,
                                   transaction: SignedTransactionAPI) -> None:
-    gas_cost = transaction.gas * transaction.gas_price
+    max_gas_cost = transaction.gas * state.get_gas_price(transaction)
     sender_balance = state.get_balance(transaction.sender)
 
-    if sender_balance < gas_cost:
+    if sender_balance < max_gas_cost:
         raise ValidationError(
             f"Sender {transaction.sender!r} cannot afford txn gas "
-            f"{gas_cost} with account balance {sender_balance}"
+            f"{max_gas_cost} with account balance {sender_balance}"
         )
 
-    total_cost = transaction.value + gas_cost
+    total_cost = transaction.value + max_gas_cost
 
     if sender_balance < total_cost:
-        raise ValidationError("Sender account balance cannot afford txn")
+        raise ValidationError(
+            f"Sender does not have enough balance to cover transaction value and gas "
+            f" (has {sender_balance}, needs {total_cost})"
+        )
 
     sender_nonce = state.get_nonce(transaction.sender)
     if sender_nonce != transaction.nonce:

eth/vm/forks/london/state.py

@@ -1,15 +1,12 @@
-from eth.vm.forks.frontier.constants import REFUND_SELFDESTRUCT
 from typing import Type
 
 from eth_hash.auto import keccak
-from eth_utils.exceptions import ValidationError
 from eth_utils import (
     encode_hex,
 )
 
 from eth.abc import (
     AccountDatabaseAPI,
-    ComputationAPI,
     MessageAPI,
     SignedTransactionAPI,
     StateAPI,
@@ -18,7 +15,6 @@
 )
 from eth.constants import (
     CREATE_CONTRACT_ADDRESS,
-    SECPK1_N,
 )
 from eth.db.account import (
     AccountDB
@@ -90,82 +86,31 @@ def build_evm_message(self, transaction: SignedTransactionAPI) -> MessageAPI:
         )
         return message
 
-    def finalize_computation(
-            self,
-            transaction: SignedTransactionAPI,
-            computation: ComputationAPI
-    ) -> ComputationAPI:
-        transaction_context = self.vm_state.get_transaction_context(transaction)
-
-        # Self Destruct Refunds
-        num_deletions = len(computation.get_accounts_for_deletion())
-        if num_deletions:
-            computation.refund_gas(REFUND_SELFDESTRUCT * num_deletions)
-
-        # Gas Refunds
-        gas_remaining = computation.get_gas_remaining()
-        gas_refunded = computation.get_gas_refund()
-        gas_used = transaction.gas - gas_remaining
-        gas_refund = min(gas_refunded, gas_used // 2)
-        gas_refund_amount = (gas_refund + gas_remaining) * transaction_context.gas_price
-
-        if gas_refund_amount:
-            self.vm_state.logger.debug2(
-                'TRANSACTION REFUND: %s -> %s',
-                gas_refund_amount,
-                encode_hex(computation.msg.sender),
-            )
-
-            self.vm_state.delta_balance(computation.msg.sender, gas_refund_amount)
-
-        # Miner Fees
-        transaction_fee = \
-            (transaction.gas - gas_remaining - gas_refund) * transaction.max_priority_fee_per_gas
-        self.vm_state.logger.debug2(
-            'TRANSACTION FEE: %s -> %s',
-            transaction_fee,
-            encode_hex(self.vm_state.coinbase),
-        )
-        self.vm_state.delta_balance(self.vm_state.coinbase, transaction_fee)
-
-        # Process Self Destructs
-        for account, _ in computation.get_accounts_for_deletion():
-            # TODO: need to figure out how we prevent multiple selfdestructs from
-            # the same account and if this is the right place to put this.
-            self.vm_state.logger.debug2('DELETING ACCOUNT: %s', encode_hex(account))
-
-            # TODO: this balance setting is likely superflous and can be
-            # removed since `delete_account` does this.
-            self.vm_state.set_balance(account, 0)
-            self.vm_state.delete_account(account)
-
-        return computation
-
 
 class LondonState(BerlinState):
     account_db_class: Type[AccountDatabaseAPI] = AccountDB
     computation_class = LondonComputation
     transaction_executor_class: Type[TransactionExecutorAPI] = LondonTransactionExecutor
 
+    def get_tip(self, transaction: SignedTransactionAPI) -> int:
+        return min(
+            transaction.max_fee_per_gas - self.execution_context.base_fee_per_gas,
+            transaction.max_priority_fee_per_gas,
+        )
+
+    def get_gas_price(self, transaction: SignedTransactionAPI) -> int:
+        return min(
+            transaction.max_fee_per_gas,
+            transaction.max_priority_fee_per_gas + self.execution_context.base_fee_per_gas,
+        )
+
     def validate_transaction(
         self,
         transaction: SignedTransactionAPI
     ) -> None:
-        # frontier validation (without the gas price checks)
-        sender_nonce = self.get_nonce(transaction.sender)
-        if sender_nonce != transaction.nonce:
-            raise ValidationError(
-                f"Invalid transaction nonce: Expected {sender_nonce}, but got {transaction.nonce}"
-            )
-
-        # homestead validation
-        if transaction.s > SECPK1_N // 2 or transaction.s == 0:
-            raise ValidationError("Invalid signature S value")
-
         validate_london_normalized_transaction(
             state=self,
             transaction=transaction,
-            base_fee_per_gas=self.execution_context.base_fee_per_gas
         )
 
     def get_transaction_context(self: StateAPI,

eth/vm/forks/london/transactions.py

@@ -222,6 +222,7 @@ class LondonTypedTransaction(TypedTransaction):
 class LondonTransactionBuilder(BerlinTransactionBuilder):
     legacy_signed = LondonLegacyTransaction
     legacy_unsigned = LondonUnsignedLegacyTransaction
+    typed_transaction = LondonTypedTransaction
 
     @classmethod
     def new_unsigned_fee_burn_transaction(

eth/vm/forks/london/validation.py

@@ -1,47 +1,29 @@
+from eth_utils.exceptions import ValidationError
+
 from eth.abc import (
     SignedTransactionAPI,
     StateAPI
 )
-
-from eth_utils.exceptions import ValidationError
+from eth.vm.forks.homestead.validation import (
+    validate_homestead_transaction,
+)
 
 
 def validate_london_normalized_transaction(
     state: StateAPI,
     transaction: SignedTransactionAPI,
-    base_fee_per_gas: int
 ) -> None:
     """
     Validates a London normalized transaction.
 
     Raise `eth.exceptions.ValidationError` if the sender cannot
     afford to send this transaction.
     """
+    base_fee_per_gas = state.execution_context.base_fee_per_gas
     if transaction.max_fee_per_gas < base_fee_per_gas:
         raise ValidationError(
             f"Sender's max fee per gas ({transaction.max_fee_per_gas}) is "
             f"lower than block's base fee per gas ({base_fee_per_gas})"
         )
 
-    sender_balance = state.get_balance(transaction.sender)
-    if sender_balance < transaction.value:
-        # This check is redundant to the later total_transaction_cost check,
-        #   but is helpful for clear error messages.
-        raise ValidationError(
-            f"Sender {transaction.sender!r} cannot afford txn value"
-            f"{transaction.value} with account balance {sender_balance}"
-        )
-
-    priority_fee_per_gas = min(
-        transaction.max_priority_fee_per_gas,
-        transaction.max_fee_per_gas - base_fee_per_gas,
-    )
-
-    effective_gas_price = priority_fee_per_gas + base_fee_per_gas
-    total_transaction_cost = transaction.value + effective_gas_price * transaction.gas
-
-    if sender_balance < total_transaction_cost:
-        raise ValidationError(
-            f"Sender does not have enough balance to cover transaction value and gas "
-            f" (has {sender_balance}, needs {total_transaction_cost})"
-        )
+    validate_homestead_transaction(state, transaction)

eth/vm/state.py

@@ -88,18 +88,11 @@ def difficulty(self) -> int:
     def gas_limit(self) -> int:
         return self.execution_context.gas_limit
 
+    def get_tip(self, transaction: SignedTransactionAPI) -> int:
+        return transaction.gas_price
+
     def get_gas_price(self, transaction: SignedTransactionAPI) -> int:
-        execution_context = self.execution_context
-        try:
-            base_gas_price = execution_context.base_fee_per_gas
-        except AttributeError:
-            return transaction.gas_price
-        else:
-            effective_price = min(
-                transaction.max_fee_per_gas,
-                transaction.max_priority_fee_per_gas + base_gas_price,
-            )
-            return effective_price
+        return transaction.gas_price
 
     #
     # Access to account db