feat: integrate alloy-eips (#2078)

Author: klkvr

Cargo.lock

@@ -53,6 +53,11 @@ statetest-types = { path = "crates/statetest-types", package = "revm-statetest-t
 context = { path = "crates/context", package = "revm-context", version = "1.0.0", default-features = false }
 context-interface = { path = "crates/context/interface", package = "revm-context-interface", version = "1.0.0", default-features = false }
 handler = { path = "crates/handler", package = "revm-handler", version = "1.0.0", default-features = false }
+
+# alloy
+alloy-eip2930 = { version = "0.1.0", default-features = false }
+alloy-eip7702 = { version = "0.5.0", default-features = false }
+
 # misc
 cfg-if = { version = "1.0", default-features = false }
 auto_impl = { version = "1.2.0" }

Cargo.toml

@@ -383,13 +383,8 @@ pub fn execute_test_suite(
                     .transaction
                     .access_lists
                     .get(test.indexes.data)
-                    .and_then(Option::as_deref)
-                    .map(|access_list| {
-                        access_list
-                            .iter()
-                            .map(|item| (item.address, item.storage_keys.clone()))
-                            .collect()
-                    })
+                    .cloned()
+                    .flatten()
                     .unwrap_or_default();
 
                 tx.authorization_list = unit

bins/revme/src/cmd/statetest/runner.rs

@@ -32,6 +32,10 @@ specification.workspace = true
 bytecode.workspace = true
 auto_impl.workspace = true
 
+# alloy
+alloy-eip2930.workspace = true
+alloy-eip7702 = { workspace = true, features = ["k256"] }
+
 # misc
 derive-where.workspace = true
 cfg-if.workspace = true

crates/context/Cargo.toml

@@ -1,3 +1,5 @@
+use alloy_eip2930::AccessList;
+use alloy_eip7702::SignedAuthorization;
 use context_interface::transaction::AuthorizationItem;
 use context_interface::Transaction;
 use core::fmt::Debug;
@@ -39,7 +41,7 @@ pub struct TxEnv {
     /// Added in [EIP-2930].
     ///
     /// [EIP-2930]: https://eips.ethereum.org/EIPS/eip-2930
-    pub access_list: Vec<(Address, Vec<B256>)>,
+    pub access_list: AccessList,
 
     /// The priority fee per gas
     ///
@@ -72,7 +74,7 @@ pub struct TxEnv {
     /// Set EOA account code for one transaction via [EIP-7702].
     ///
     /// [EIP-7702]: https://eips.ethereum.org/EIPS/eip-7702
-    pub authorization_list: Vec<AuthorizationItem>,
+    pub authorization_list: Vec<SignedAuthorization>,
 }
 
 impl Default for TxEnv {
@@ -87,7 +89,7 @@ impl Default for TxEnv {
             data: Bytes::default(),
             nonce: 0,
             chain_id: Some(1), // Mainnet chain ID is 1
-            access_list: Vec::new(),
+            access_list: Default::default(),
             gas_priority_fee: Some(0),
             blob_hashes: Vec::new(),
             max_fee_per_blob_gas: 0,
@@ -132,8 +134,9 @@ impl Transaction for TxEnv {
     fn access_list(&self) -> Option<impl Iterator<Item = (&Address, &[B256])>> {
         Some(
             self.access_list
+                .0
                 .iter()
-                .map(|(address, storage_keys)| (address, storage_keys.as_slice())),
+                .map(|item| (&item.address, item.storage_keys.as_slice())),
         )
     }
 
@@ -150,7 +153,14 @@ impl Transaction for TxEnv {
     }
 
     fn authorization_list(&self) -> impl Iterator<Item = AuthorizationItem> {
-        self.authorization_list.iter().cloned()
+        self.authorization_list.iter().map(|item| {
+            (
+                item.recover_authority().ok(),
+                item.chain_id,
+                item.nonce,
+                item.address,
+            )
+        })
     }
 
     fn input(&self) -> &Bytes {

crates/context/src/tx.rs

@@ -45,7 +45,10 @@ indicatif = "0.17"
 reqwest = { version = "0.12" }
 rstest = "0.22.0"
 
+alloy-eip7702.workspace = true
 alloy-provider = "0.9.2"
+alloy-signer = "0.9.2"
+alloy-signer-local = "0.9.2"
 
 [features]
 default = ["std", "c-kzg", "secp256k1", "portable", "blst"]

crates/revm/Cargo.toml

@@ -109,19 +109,29 @@ where
 mod test {
     use super::*;
     use crate::{MainBuilder, MainContext};
+    use alloy_eip7702::Authorization;
+    use alloy_signer::SignerSync;
+    use alloy_signer_local::PrivateKeySigner;
     use bytecode::{
         opcode::{PUSH1, SSTORE},
         Bytecode,
     };
     use context::Context;
     use context_interface::TransactionType;
     use database::{BenchmarkDB, EEADDRESS, FFADDRESS};
-    use primitives::{address, TxKind, U256};
+    use primitives::{TxKind, U256};
     use specification::hardfork::SpecId;
 
     #[test]
     fn sanity_eip7702_tx() {
-        let auth = address!("0000000000000000000000000000000000000100");
+        let signer = PrivateKeySigner::random();
+        let auth = Authorization {
+            chain_id: U256::ZERO,
+            nonce: 0,
+            address: FFADDRESS,
+        };
+        let signature = signer.sign_hash_sync(&auth.signature_hash()).unwrap();
+        let auth = auth.into_signed(signature);
 
         let bytecode = Bytecode::new_legacy([PUSH1, 0x01, PUSH1, 0x01, SSTORE].into());
 
@@ -131,16 +141,16 @@ mod test {
             .modify_tx_chained(|tx| {
                 tx.tx_type = TransactionType::Eip7702.into();
                 tx.gas_limit = 100_000;
-                tx.authorization_list = vec![(Some(auth), U256::from(0), 0, FFADDRESS)];
+                tx.authorization_list = vec![auth];
                 tx.caller = EEADDRESS;
-                tx.kind = TxKind::Call(auth);
+                tx.kind = TxKind::Call(signer.address());
             });
 
         let mut evm = ctx.build_mainnet();
 
         let ok = evm.transact_previous().unwrap();
 
-        let auth_acc = ok.state.get(&auth).unwrap();
+        let auth_acc = ok.state.get(&signer.address()).unwrap();
         assert_eq!(auth_acc.info.code, Some(Bytecode::new_eip7702(FFADDRESS)));
         assert_eq!(auth_acc.info.nonce, 1);
         assert_eq!(

crates/revm/src/mainnet_exec_inspect.rs

@@ -26,3 +26,7 @@ all = "warn"
 revm = { workspace = true, features = ["std", "serde"] }
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
+
+# alloy
+alloy-eip2930 = { workspace = true, features = ["serde"] }
+alloy-eip7702 = { workspace = true, features = ["serde"] }

crates/statetest-types/Cargo.toml

@@ -1,44 +1,17 @@
-use revm::{
-    context_interface::transaction::AuthorizationItem,
-    primitives::{Address, U256},
-    specification::eip2::SECP256K1N_HALF,
-};
+use alloy_eip7702::SignedAuthorization;
 use serde::{Deserialize, Serialize};
 
 /// Struct for test authorization
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
 pub struct TestAuthorization {
-    /// The chain ID of the authorization.
-    pub chain_id: U256,
-    /// The address of the authorization.
-    pub address: Address,
-    /// The nonce for the authorization.
-    pub nonce: U256,
-    v: U256,
-    r: U256,
-    s: U256,
-    signer: Option<Address>,
+    #[serde(flatten)]
+    inner: SignedAuthorization,
 }
 
-impl From<TestAuthorization> for AuthorizationItem {
-    fn from(auth: TestAuthorization) -> AuthorizationItem {
-        let mut signer = auth.signer;
-
-        if auth.s > SECP256K1N_HALF {
-            signer = None
-        }
-
-        if auth.v > U256::from(1) {
-            signer = None
-        }
-
-        (
-            signer,
-            auth.chain_id,
-            auth.nonce.try_into().unwrap_or(u64::MAX),
-            auth.address,
-        )
+impl From<TestAuthorization> for SignedAuthorization {
+    fn from(auth: TestAuthorization) -> Self {
+        auth.inner
     }
 }
 

crates/statetest-types/src/test_authorization.rs

@@ -1,11 +1,11 @@
+use crate::{deserializer::deserialize_maybe_empty, TestAuthorization};
+use alloy_eip2930::AccessList;
 use revm::{
     context_interface::transaction::TransactionType,
     primitives::{Address, Bytes, B256, U256},
 };
 use serde::{Deserialize, Serialize};
 
-use crate::{deserializer::deserialize_maybe_empty, TestAuthorization};
-
 /// Transaction parts.
 #[derive(Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -25,7 +25,7 @@ pub struct TransactionParts {
     pub max_priority_fee_per_gas: Option<U256>,
 
     #[serde(default)]
-    pub access_lists: Vec<Option<Vec<AccessListItem>>>,
+    pub access_lists: Vec<Option<AccessList>>,
     pub authorization_list: Option<Vec<TestAuthorization>>,
     #[serde(default)]
     pub blob_versioned_hashes: Vec<B256>,
@@ -82,13 +82,6 @@ pub struct TxPartIndices {
     pub value: usize,
 }
 
-#[derive(Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct AccessListItem {
-    pub address: Address,
-    pub storage_keys: Vec<B256>,
-}
-
 #[cfg(test)]
 mod test {
 

crates/statetest-types/src/transaction.rs

@@ -126,11 +126,7 @@ async fn main() -> anyhow::Result<()> {
             etx.chain_id = Some(chain_id);
             etx.nonce = tx.nonce();
             if let Some(access_list) = tx.access_list() {
-                etx.access_list = access_list
-                    .0
-                    .iter()
-                    .map(|item| (item.address, item.storage_keys.clone()))
-                    .collect();
+                etx.access_list = access_list.clone()
             } else {
                 etx.access_list = Default::default();
             }