!!TEMP COMMIT!! Remove before merging forks/osaka to master

add specific exceptions on tests

- update exceptions for other forks
- fix tests
- use fork module
- rename to NonceOverFlowError
- revert load test catching specific exc
- style: indent comment line

Author: souradeep-das

src/ethereum/arrow_glacier/transactions.py

@@ -13,7 +13,11 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
 from .exceptions import TransactionTypeError
 from .fork_types import Address
@@ -337,15 +341,17 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     return intrinsic_gas
 
 

src/ethereum/berlin/transactions.py

@@ -13,7 +13,11 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
 from .exceptions import TransactionTypeError
 from .fork_types import Address
@@ -254,15 +258,17 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     return intrinsic_gas
 
 

src/ethereum/byzantium/transactions.py

@@ -12,7 +12,11 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
 from .fork_types import Address
 
@@ -110,15 +114,17 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     return intrinsic_gas
 
 

src/ethereum/cancun/exceptions.py

@@ -101,3 +101,9 @@ class PriorityFeeGreaterThanMaxFeeError(InvalidTransaction):
     """
     The priority fee is greater than the maximum fee per gas.
     """
+
+
+class InitCodeTooLargeError(InvalidTransaction):
+    """
+    The init code of the transaction is too large.
+    """

src/ethereum/cancun/transactions.py

@@ -13,9 +13,13 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
-from .exceptions import TransactionTypeError
+from .exceptions import InitCodeTooLargeError, TransactionTypeError
 from .fork_types import Address, VersionedHash
 
 TX_BASE_COST = Uint(21000)
@@ -439,19 +443,23 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`. It also raises an
+    `InitCodeTooLargeError` if the code size of a contract creation transaction
+    exceeds the maximum allowed size.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     from .vm.interpreter import MAX_INIT_CODE_SIZE
 
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     if tx.to == Bytes0(b"") and len(tx.data) > MAX_INIT_CODE_SIZE:
-        raise InvalidTransaction("Code size too large")
+        raise InitCodeTooLargeError("Code size too large")
 
     return intrinsic_gas
 

src/ethereum/constantinople/transactions.py

@@ -12,7 +12,11 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
 from .fork_types import Address
 
@@ -110,15 +114,17 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     return intrinsic_gas
 
 

src/ethereum/dao_fork/transactions.py

@@ -12,7 +12,11 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
 from .fork_types import Address
 
@@ -110,15 +114,17 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     return intrinsic_gas
 
 

src/ethereum/exceptions.py

@@ -60,3 +60,16 @@ class GasUsedExceedsLimitError(InvalidTransaction):
     Thrown when a transaction's gas usage exceeds the gas available in the
     block.
     """
+
+
+class InsufficientTransactionGasError(InvalidTransaction):
+    """
+    Thrown when a transaction does not provide enough gas to cover its
+    intrinsic cost.
+    """
+
+
+class NonceOverflowError(InvalidTransaction):
+    """
+    Thrown when a transaction's nonce is greater than `2**64 - 2`.
+    """

src/ethereum/frontier/transactions.py

@@ -12,7 +12,11 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
 from .fork_types import Address
 
@@ -105,15 +109,17 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     return intrinsic_gas
 
 

src/ethereum/gray_glacier/transactions.py

@@ -13,7 +13,11 @@
 
 from ethereum.crypto.elliptic_curve import SECP256K1N, secp256k1_recover
 from ethereum.crypto.hash import Hash32, keccak256
-from ethereum.exceptions import InvalidSignatureError, InvalidTransaction
+from ethereum.exceptions import (
+    InsufficientTransactionGasError,
+    InvalidSignatureError,
+    NonceOverflowError,
+)
 
 from .exceptions import TransactionTypeError
 from .fork_types import Address
@@ -337,15 +341,17 @@ def validate_transaction(tx: Transaction) -> Uint:
 
     This function takes a transaction as a parameter and returns the intrinsic
     gas cost of the transaction after validation. It throws an
-    `InvalidTransaction` exception if the transaction is invalid.
+    `InsufficientTransactionGasError` exception if the transaction does not
+    provide enough gas to cover the intrinsic cost, and a `NonceOverflowError`
+    exception if the nonce is greater than `2**64 - 2`.
 
     [EIP-2681]: https://eips.ethereum.org/EIPS/eip-2681
     """
     intrinsic_gas = calculate_intrinsic_cost(tx)
     if intrinsic_gas > tx.gas:
-        raise InvalidTransaction("Insufficient gas")
+        raise InsufficientTransactionGasError("Insufficient gas")
     if U256(tx.nonce) >= U256(U64.MAX_VALUE):
-        raise InvalidTransaction("Nonce too high")
+        raise NonceOverflowError("Nonce too high")
     return intrinsic_gas