Move tip v burn validation to Frontier to dedup

Author: carver

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,7 +1,6 @@
 from typing import Type
 
 from eth_hash.auto import keccak
-from eth_utils.exceptions import ValidationError
 from eth_utils import (
     encode_hex,
 )
@@ -16,7 +15,6 @@
 )
 from eth.constants import (
     CREATE_CONTRACT_ADDRESS,
-    SECPK1_N,
 )
 from eth.db.account import (
     AccountDB
@@ -110,21 +108,9 @@ 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/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)