feat(fw): Add type-4 transaction and authorization tuple type

Author: marioevz

src/ethereum_test_tools/__init__.py

@@ -20,6 +20,7 @@
     Account,
     Address,
     Alloc,
+    AuthorizationTuple,
     DepositRequest,
     EngineAPIError,
     Environment,
@@ -69,6 +70,7 @@
     "Account",
     "Address",
     "Alloc",
+    "AuthorizationTuple",
     "BaseFixture",
     "BaseTest",
     "Block",

src/ethereum_test_tools/common/__init__.py

@@ -40,6 +40,7 @@
     AccessList,
     Account,
     Alloc,
+    AuthorizationTuple,
     DepositRequest,
     Environment,
     Removable,
@@ -57,6 +58,7 @@
     "AddrAA",
     "AddrBB",
     "Alloc",
+    "AuthorizationTuple",
     "Bloom",
     "Bytes",
     "DepositRequest",

src/ethereum_test_tools/common/types.py

@@ -16,6 +16,7 @@
     List,
     Sequence,
     SupportsBytes,
+    Tuple,
     Type,
     TypeAlias,
     TypeVar,
@@ -980,6 +981,115 @@ def to_list(self) -> List[Address | List[Hash]]:
         return [self.address, self.storage_keys]
 
 
+class AuthorizationTupleGeneric(CamelModel, Generic[NumberBoundTypeVar]):
+    """
+    Authorization tuple for transactions.
+    """
+
+    chain_id: NumberBoundTypeVar = Field(1)  # type: ignore
+    address: Address
+    nonce: List[NumberBoundTypeVar] | NumberBoundTypeVar | None = None
+
+    v: NumberBoundTypeVar = Field(0)  # type: ignore
+    r: NumberBoundTypeVar = Field(0)  # type: ignore
+    s: NumberBoundTypeVar = Field(0)  # type: ignore
+
+    magic: ClassVar[int] = 0x05
+
+    def model_post_init(self, __context: Any) -> None:
+        """
+        Automatically converts the nonce to a list if it is not already.
+        """
+        super().model_post_init(__context)
+        if self.nonce is not None and not isinstance(self.nonce, list):
+            self.nonce = [self.nonce]
+
+    def nonce_list(self) -> List[Uint]:
+        """
+        Returns the nonce as a list.
+        """
+        if self.nonce is None:
+            return []
+        return (
+            [Uint(n) for n in self.nonce] if isinstance(self.nonce, list) else [Uint(self.nonce)]
+        )
+
+    def to_list(self) -> List[Any]:
+        """
+        Returns the authorization tuple as a list of serializable elements.
+        """
+        return [
+            Uint(self.chain_id),
+            self.address,
+            self.nonce_list(),
+            Uint(self.v),
+            Uint(self.r),
+            Uint(self.s),
+        ]
+
+    def signing_hash(self) -> Hash:
+        """
+        Returns the data to be signed.
+        """
+        return Hash(
+            keccak256(
+                int.to_bytes(self.magic, length=1, byteorder="big")
+                + eth_rlp.encode(
+                    [
+                        Uint(self.chain_id),
+                        self.address,
+                        self.nonce_list(),
+                    ]
+                )
+            )
+        )
+
+    def signature(self, private_key: Hash) -> Tuple[int, int, int]:
+        """
+        Returns the signature of the authorization tuple.
+        """
+        signing_hash = self.signing_hash()
+        signature_bytes = PrivateKey(secret=private_key).sign_recoverable(
+            signing_hash, hasher=None
+        )
+        return (
+            signature_bytes[64],
+            int.from_bytes(signature_bytes[0:32], byteorder="big"),
+            int.from_bytes(signature_bytes[32:64], byteorder="big"),
+        )
+
+
+class AuthorizationTuple(AuthorizationTupleGeneric[HexNumber]):
+    """
+    Authorization tuple for transactions.
+    """
+
+    signer: EOA | None = None
+    secret_key: Hash | None = None
+
+    def model_post_init(self, __context: Any) -> None:
+        """
+        Automatically signs the authorization tuple if a secret key or sender are provided.
+        """
+        super().model_post_init(__context)
+
+        if self.secret_key is not None:
+            self.sign(self.secret_key)
+        elif self.signer is not None:
+            assert self.signer.key is not None, "signer must have a key"
+            self.sign(self.signer.key)
+
+    def sign(self, private_key: Hash) -> None:
+        """
+        Signs the authorization tuple with a private key.
+        """
+        signature = self.signature(private_key)
+
+        self.v = HexNumber(signature[0])
+        self.r = HexNumber(signature[1])
+        self.s = HexNumber(signature[2])
+
+
 class TransactionGeneric(BaseModel, Generic[NumberBoundTypeVar]):
     """
     Generic transaction type used as a parent for Transaction and FixtureTransaction (blockchain).
@@ -1070,6 +1180,8 @@ class Transaction(TransactionGeneric[HexNumber], TransactionTransitionToolConver
     to: Address | None = Field(Address(0xAA))
     data: Bytes = Field(Bytes(b""), alias="input")
 
+    authorization_tuples: List[AuthorizationTuple] | None = None
+
     secret_key: Hash | None = None
     error: List[TransactionException] | TransactionException | None = Field(None, exclude=True)
 
@@ -1117,7 +1229,9 @@ def model_post_init(self, __context):
 
         if "ty" not in self.model_fields_set:
             # Try to deduce transaction type from included fields
-            if self.max_fee_per_blob_gas is not None or self.blob_kzg_commitments is not None:
+            if self.authorization_tuples is not None:
+                self.ty = 4
+            elif self.max_fee_per_blob_gas is not None or self.blob_kzg_commitments is not None:
                 self.ty = 3
             elif self.max_fee_per_gas is not None or self.max_priority_fee_per_gas is not None:
                 self.ty = 2
@@ -1150,6 +1264,9 @@ def model_post_init(self, __context):
         if self.ty == 3 and self.max_fee_per_blob_gas is None:
             self.max_fee_per_blob_gas = 1
 
+        if self.ty == 4 and self.authorization_tuples is None:
+            self.authorization_tuples = []
+
         if "nonce" not in self.model_fields_set and self.sender is not None:
             self.nonce = HexNumber(self.sender.get_nonce())
 
@@ -1233,18 +1350,40 @@ def signing_envelope(self) -> List[Any]:
         Returns the list of values included in the envelope used for signing.
         """
         to = self.to if self.to else bytes()
-        if self.ty == 3:
+        if self.ty == 4:
+            # EIP-7702: https://eips.ethereum.org/EIPS/eip-7702
+            if self.max_priority_fee_per_gas is None:
+                raise ValueError(f"max_priority_fee_per_gas must be set for type {self.ty} tx")
+            if self.max_fee_per_gas is None:
+                raise ValueError(f"max_fee_per_gas must be set for type {self.ty} tx")
+            if self.access_list is None:
+                raise ValueError(f"access_list must be set for type {self.ty} tx")
+            if self.authorization_tuples is None:
+                raise ValueError(f"authorization_tuples must be set for type {self.ty} tx")
+            return [
+                Uint(self.chain_id),
+                Uint(self.nonce),
+                Uint(self.max_priority_fee_per_gas),
+                Uint(self.max_fee_per_gas),
+                Uint(self.gas_limit),
+                to,
+                Uint(self.value),
+                self.data,
+                [a.to_list() for a in self.access_list],
+                [a.to_list() for a in self.authorization_tuples],
+            ]
+        elif self.ty == 3:
             # EIP-4844: https://eips.ethereum.org/EIPS/eip-4844
             if self.max_priority_fee_per_gas is None:
-                raise ValueError("max_priority_fee_per_gas must be set for type 3 tx")
+                raise ValueError(f"max_priority_fee_per_gas must be set for type {self.ty} tx")
             if self.max_fee_per_gas is None:
-                raise ValueError("max_fee_per_gas must be set for type 3 tx")
+                raise ValueError(f"max_fee_per_gas must be set for type {self.ty} tx")
             if self.max_fee_per_blob_gas is None:
-                raise ValueError("max_fee_per_blob_gas must be set for type 3 tx")
+                raise ValueError(f"max_fee_per_blob_gas must be set for type {self.ty} tx")
             if self.blob_versioned_hashes is None:
-                raise ValueError("blob_versioned_hashes must be set for type 3 tx")
+                raise ValueError(f"blob_versioned_hashes must be set for type {self.ty} tx")
             if self.access_list is None:
-                raise ValueError("access_list must be set for type 3 tx")
+                raise ValueError(f"access_list must be set for type {self.ty} tx")
             return [
                 Uint(self.chain_id),
                 Uint(self.nonce),
@@ -1261,11 +1400,11 @@ def signing_envelope(self) -> List[Any]:
         elif self.ty == 2:
             # EIP-1559: https://eips.ethereum.org/EIPS/eip-1559
             if self.max_priority_fee_per_gas is None:
-                raise ValueError("max_priority_fee_per_gas must be set for type 2 tx")
+                raise ValueError(f"max_priority_fee_per_gas must be set for type {self.ty} tx")
             if self.max_fee_per_gas is None:
-                raise ValueError("max_fee_per_gas must be set for type 2 tx")
+                raise ValueError(f"max_fee_per_gas must be set for type {self.ty} tx")
             if self.access_list is None:
-                raise ValueError("access_list must be set for type 2 tx")
+                raise ValueError(f"access_list must be set for type {self.ty} tx")
             return [
                 Uint(self.chain_id),
                 Uint(self.nonce),
@@ -1280,9 +1419,9 @@ def signing_envelope(self) -> List[Any]:
         elif self.ty == 1:
             # EIP-2930: https://eips.ethereum.org/EIPS/eip-2930
             if self.gas_price is None:
-                raise ValueError("gas_price must be set for type 1 tx")
+                raise ValueError(f"gas_price must be set for type {self.ty} tx")
             if self.access_list is None:
-                raise ValueError("access_list must be set for type 1 tx")
+                raise ValueError(f"access_list must be set for type {self.ty} tx")
 
             return [
                 Uint(self.chain_id),
@@ -1296,7 +1435,7 @@ def signing_envelope(self) -> List[Any]:
             ]
         elif self.ty == 0:
             if self.gas_price is None:
-                raise ValueError("gas_price must be set for type 0 tx")
+                raise ValueError(f"gas_price must be set for type {self.ty} tx")
 
             if self.protected:
                 # EIP-155: https://eips.ethereum.org/EIPS/eip-155
@@ -1338,11 +1477,11 @@ def payload_body(self) -> List[Any]:
         elif self.ty == 3 and self.wrapped_blob_transaction:
             # EIP-4844: https://eips.ethereum.org/EIPS/eip-4844
             if self.blobs is None:
-                raise ValueError("blobs must be set for type 3 tx")
+                raise ValueError(f"blobs must be set for type {self.ty} tx")
             if self.blob_kzg_commitments is None:
-                raise ValueError("blob_kzg_commitments must be set for type 3 tx")
+                raise ValueError(f"blob_kzg_commitments must be set for type {self.ty} tx")
             if self.blob_kzg_proofs is None:
-                raise ValueError("blob_kzg_proofs must be set for type 3 tx")
+                raise ValueError(f"blob_kzg_proofs must be set for type {self.ty} tx")
             return [
                 signing_envelope + [Uint(self.v), Uint(self.r), Uint(self.s)],
                 list(self.blobs),

src/ethereum_test_tools/spec/blockchain/types.py

@@ -33,6 +33,7 @@
 from ...common.constants import EmptyOmmersRoot, EngineAPIError
 from ...common.types import (
     Alloc,
+    AuthorizationTupleGeneric,
     CamelModel,
     DepositRequest,
     DepositRequestGeneric,
@@ -509,11 +510,28 @@ def from_fixture_header(
         return new_payload
 
 
+class FixtureAuthorizationTuple(AuthorizationTupleGeneric[ZeroPaddedHexNumber]):
+    """
+    Authorization tuple for fixture transactions.
+    """
+
+    @classmethod
+    def from_authorization_tuple(
+        cls, auth_tuple: AuthorizationTupleGeneric
+    ) -> "FixtureAuthorizationTuple":
+        """
+        Returns a FixtureAuthorizationTuple from an AuthorizationTuple.
+        """
+        return cls(**auth_tuple.model_dump())
+
+
 class FixtureTransaction(TransactionFixtureConverter, TransactionGeneric[ZeroPaddedHexNumber]):
     """
     Representation of an Ethereum transaction within a test Fixture.
     """
 
+    authorization_tuples: List[FixtureAuthorizationTuple] | None = None
+
     @classmethod
     def from_transaction(cls, tx: Transaction) -> "FixtureTransaction":
         """

src/ethereum_test_tools/spec/state/types.py

@@ -12,6 +12,7 @@
 from ...common.types import (
     AccessList,
     Alloc,
+    AuthorizationTupleGeneric,
     CamelModel,
     EnvironmentGeneric,
     Transaction,
@@ -29,6 +30,21 @@ class FixtureEnvironment(EnvironmentGeneric[ZeroPaddedHexNumber]):
     prev_randao: Hash | None = Field(None, alias="currentRandom")  # type: ignore
 
 
+class FixtureAuthorizationTuple(AuthorizationTupleGeneric[ZeroPaddedHexNumber]):
+    """
+    Authorization tuple for fixture transactions.
+    """
+
+    @classmethod
+    def from_authorization_tuple(
+        cls, auth_tuple: AuthorizationTupleGeneric
+    ) -> "FixtureAuthorizationTuple":
+        """
+        Returns a FixtureAuthorizationTuple from an AuthorizationTuple.
+        """
+        return cls(**auth_tuple.model_dump())
+
+
 class FixtureTransaction(TransactionFixtureConverter):
     """
     Type used to describe a transaction in a state test.
@@ -43,6 +59,7 @@ class FixtureTransaction(TransactionFixtureConverter):
     value: List[ZeroPaddedHexNumber]
     data: List[Bytes]
     access_lists: List[List[AccessList]] | None = None
+    authorization_tuples: List[FixtureAuthorizationTuple] | None = None
     max_fee_per_blob_gas: ZeroPaddedHexNumber | None = None
     blob_versioned_hashes: Sequence[Hash] | None = None
     sender: Address | None = None