chore: some fixes, typed data

crates/anvil/Cargo.toml

@@ -41,6 +41,7 @@ alloy-network.workspace = true
 alloy-rlp.workspace = true
 alloy-signer = { workspace = true, features = ["eip712", "mnemonic"] }
 alloy-sol-types = { workspace = true, features = ["std"] }
+alloy-dyn-abi = { workspace = true, features = ["std", "eip712"] }
 alloy-rpc-types.workspace = true
 alloy-rpc-trace-types.workspace = true
 alloy-providers.workspace = true

crates/anvil/core/Cargo.toml

@@ -21,6 +21,7 @@ alloy-rlp.workspace = true
 alloy-eips.workspace = true
 alloy-network = { workspace = true, features = ["k256"] }
 alloy-consensus.workspace = true
+alloy-dyn-abi = { workspace = true, features = ["std", "eip712"] }
 ethers-core = { workspace = true, features = ["optimism"] }
 # theses are not used by anvil-core, but are required by ethers, because pulled in via foundry-common
 ethers-contract = { workspace = true, features = ["optimism"] }

crates/anvil/core/src/eth/mod.rs

@@ -9,7 +9,6 @@ use alloy_rpc_types::{
     state::StateOverride,
     BlockId, BlockNumberOrTag as BlockNumber, CallRequest, Filter,
 };
-use ethers_core::types::transaction::eip712::TypedData;
 
 pub mod alloy_block;
 pub mod alloy_proof;
@@ -41,7 +40,7 @@ pub struct Params<T: Default> {
 }
 
 /// Represents ethereum JSON-RPC API
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(tag = "method", content = "params"))]
 pub enum EthRequest {
@@ -158,7 +157,7 @@ pub enum EthRequest {
 
     /// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md), and includes full support of arrays and recursive data structures.
     #[cfg_attr(feature = "serde", serde(rename = "eth_signTypedData_v4"))]
-    EthSignTypedDataV4(Address, TypedData),
+    EthSignTypedDataV4(Address, alloy_dyn_abi::TypedData),
 
     #[cfg_attr(feature = "serde", serde(rename = "eth_sendTransaction", with = "sequence"))]
     EthSendTransaction(Box<EthTransactionRequest>),
@@ -736,7 +735,7 @@ pub enum EthPubSub {
 }
 
 /// Container type for either a request or a pub sub
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(untagged))]
 pub enum EthRpcCall {

crates/anvil/core/src/eth/transaction/alloy.rs

@@ -2,7 +2,7 @@ use crate::eth::{
     transaction::optimism::{DepositTransaction, DepositTransactionRequest},
     utils::eip_to_revm_access_list,
 };
-use alloy_consensus::{ReceiptWithBloom, TxEip1559, TxEip2930, TxLegacy, TxEnvelope};
+use alloy_consensus::{ReceiptWithBloom, TxEip1559, TxEip2930, TxEnvelope, TxLegacy};
 use alloy_network::{Signed, Transaction, TxKind};
 use alloy_primitives::{Address, Bloom, Bytes, Log, Signature, TxHash, B256, U256, U64};
 use alloy_rlp::{Decodable, Encodable};
@@ -691,10 +691,10 @@ impl TypedTransaction {
     pub fn r#type(&self) -> Option<u8> {
         match self {
             TypedTransaction::Enveloped(tx) => match tx {
-                TxEnvelope::Legacy(tx) => None,
-                TxEnvelope::TaggedLegacy(tx) => Some(0),
-                TxEnvelope::Eip2930(tx) => Some(1),
-                TxEnvelope::Eip1559(tx) => Some(2),
+                TxEnvelope::Legacy(_) => None,
+                TxEnvelope::TaggedLegacy(_) => Some(0),
+                TxEnvelope::Eip2930(_) => Some(1),
+                TxEnvelope::Eip1559(_) => Some(2),
             },
             TypedTransaction::Deposit(_) => Some(0x7E),
         }
@@ -708,58 +708,56 @@ impl TypedTransaction {
     /// Returns a helper type that contains commonly used values as fields
     pub fn essentials(&self) -> TransactionEssentials {
         match self {
-            TypedTransaction::Enveloped(tx) => {
-                match tx {
-                    TxEnvelope::Legacy(t) => TransactionEssentials {
-                        kind: t.tx().to,
-                        input: t.input.clone(),
-                        nonce: U256::from(t.tx().nonce),
-                        gas_limit: U256::from(t.tx().gas_limit),
-                        gas_price: Some(U256::from(t.tx().gas_price)),
-                        max_fee_per_gas: None,
-                        max_priority_fee_per_gas: None,
-                        value: t.value,
-                        chain_id: t.tx().chain_id,
-                        access_list: Default::default(),
-                    },
-                    TxEnvelope::TaggedLegacy(t) => TransactionEssentials {
-                        kind: t.tx().to,
-                        input: t.input.clone(),
-                        nonce: U256::from(t.tx().nonce),
-                        gas_limit: U256::from(t.tx().gas_limit),
-                        gas_price: Some(U256::from(t.tx().gas_price)),
-                        max_fee_per_gas: None,
-                        max_priority_fee_per_gas: None,
-                        value: t.value,
-                        chain_id: t.tx().chain_id,
-                        access_list: Default::default(),
-                    },
-                    TxEnvelope::Eip2930(t) => TransactionEssentials {
-                        kind: t.tx().to,
-                        input: t.input.clone(),
-                        nonce: U256::from(t.tx().nonce),
-                        gas_limit: U256::from(t.tx().gas_limit),
-                        gas_price: Some(U256::from(t.tx().gas_price)),
-                        max_fee_per_gas: None,
-                        max_priority_fee_per_gas: None,
-                        value: t.value,
-                        chain_id: Some(t.chain_id),
-                        access_list: to_alloy_access_list(t.access_list.clone()),
-                    },
-                    TxEnvelope::Eip1559(t) => TransactionEssentials {
-                        kind: t.to,
-                        input: t.input.clone(),
-                        nonce: U256::from(t.nonce),
-                        gas_limit: U256::from(t.gas_limit),
-                        gas_price: None,
-                        max_fee_per_gas: Some(U256::from(t.max_fee_per_gas)),
-                        max_priority_fee_per_gas: Some(U256::from(t.max_priority_fee_per_gas)),
-                        value: t.value,
-                        chain_id: Some(t.chain_id),
-                        access_list: to_alloy_access_list(t.access_list.clone()),
-                    },
-                }
-            }
+            TypedTransaction::Enveloped(tx) => match tx {
+                TxEnvelope::Legacy(t) => TransactionEssentials {
+                    kind: t.tx().to,
+                    input: t.input.clone(),
+                    nonce: U256::from(t.tx().nonce),
+                    gas_limit: U256::from(t.tx().gas_limit),
+                    gas_price: Some(U256::from(t.tx().gas_price)),
+                    max_fee_per_gas: None,
+                    max_priority_fee_per_gas: None,
+                    value: t.value,
+                    chain_id: t.tx().chain_id,
+                    access_list: Default::default(),
+                },
+                TxEnvelope::TaggedLegacy(t) => TransactionEssentials {
+                    kind: t.tx().to,
+                    input: t.input.clone(),
+                    nonce: U256::from(t.tx().nonce),
+                    gas_limit: U256::from(t.tx().gas_limit),
+                    gas_price: Some(U256::from(t.tx().gas_price)),
+                    max_fee_per_gas: None,
+                    max_priority_fee_per_gas: None,
+                    value: t.value,
+                    chain_id: t.tx().chain_id,
+                    access_list: Default::default(),
+                },
+                TxEnvelope::Eip2930(t) => TransactionEssentials {
+                    kind: t.tx().to,
+                    input: t.input.clone(),
+                    nonce: U256::from(t.tx().nonce),
+                    gas_limit: U256::from(t.tx().gas_limit),
+                    gas_price: Some(U256::from(t.tx().gas_price)),
+                    max_fee_per_gas: None,
+                    max_priority_fee_per_gas: None,
+                    value: t.value,
+                    chain_id: Some(t.chain_id),
+                    access_list: to_alloy_access_list(t.access_list.clone()),
+                },
+                TxEnvelope::Eip1559(t) => TransactionEssentials {
+                    kind: t.to,
+                    input: t.input.clone(),
+                    nonce: U256::from(t.nonce),
+                    gas_limit: U256::from(t.gas_limit),
+                    gas_price: None,
+                    max_fee_per_gas: Some(U256::from(t.max_fee_per_gas)),
+                    max_priority_fee_per_gas: Some(U256::from(t.max_priority_fee_per_gas)),
+                    value: t.value,
+                    chain_id: Some(t.chain_id),
+                    access_list: to_alloy_access_list(t.access_list.clone()),
+                },
+            },
             TypedTransaction::Deposit(t) => TransactionEssentials {
                 kind: t.kind,
                 input: t.input.clone(),
@@ -1151,7 +1149,9 @@ mod tests {
         // random mainnet tx: https://etherscan.io/tx/0x86718885c4b4218c6af87d3d0b0d83e3cc465df2a05c048aa4db9f1a6f9de91f
         let bytes = hex::decode("02f872018307910d808507204d2cb1827d0094388c818ca8b9251b393131c08a736a67ccb19297880320d04823e2701c80c001a0cf024f4815304df2867a1a74e9d2707b6abda0337d2d54a4438d453f4160f190a07ac0e6b3bc9395b5b9c8b9e6d77204a236577a5b18467b9175c01de4faa208d9").unwrap();
 
-        let Ok(TypedTransaction::Enveloped(TxEnvelope::Eip1559(tx))) = TypedTransaction::decode(&mut &bytes[..]) else {
+        let Ok(TypedTransaction::Enveloped(TxEnvelope::Eip1559(tx))) =
+            TypedTransaction::decode(&mut &bytes[..])
+        else {
             panic!("decoding TypedTransaction failed");
         };
 
@@ -1171,7 +1171,9 @@ mod tests {
     fn can_recover_sender_not_normalized() {
         let bytes = hex::decode("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap();
 
-        let Ok(TypedTransaction::Enveloped(TxEnvelope::Legacy(tx))) = TypedTransaction::decode(&mut &bytes[..]) else {
+        let Ok(TypedTransaction::Enveloped(TxEnvelope::Legacy(tx))) =
+            TypedTransaction::decode(&mut &bytes[..])
+        else {
             panic!("decoding TypedTransaction failed");
         };
 

crates/anvil/core/src/eth/transaction/alloy_compat.rs

@@ -45,33 +45,35 @@ pub fn to_alloy_transaction_with_hash_and_sender(
             blob_versioned_hashes: vec![],
             other: Default::default(),
         },
-        TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::TaggedLegacy(t)) => AlloyTransaction {
-            hash,
-            nonce: U64::from(t.nonce),
-            block_hash: None,
-            block_number: None,
-            transaction_index: None,
-            from,
-            to: None,
-            value: t.value,
-            gas_price: Some(U128::from(t.gas_price)),
-            max_fee_per_gas: Some(U128::from(t.gas_price)),
-            max_priority_fee_per_gas: Some(U128::from(t.gas_price)),
-            gas: U256::from(t.gas_limit),
-            input: t.input.clone(),
-            chain_id: t.chain_id.map(U64::from),
-            signature: Some(Signature {
-                r: t.signature().r(),
-                s: t.signature().s(),
-                v: U256::from(t.signature().v().y_parity_byte()),
-                y_parity: None,
-            }),
-            access_list: None,
-            transaction_type: None,
-            max_fee_per_blob_gas: None,
-            blob_versioned_hashes: vec![],
-            other: Default::default(),
-        },
+        TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::TaggedLegacy(t)) => {
+            AlloyTransaction {
+                hash,
+                nonce: U64::from(t.nonce),
+                block_hash: None,
+                block_number: None,
+                transaction_index: None,
+                from,
+                to: None,
+                value: t.value,
+                gas_price: Some(U128::from(t.gas_price)),
+                max_fee_per_gas: Some(U128::from(t.gas_price)),
+                max_priority_fee_per_gas: Some(U128::from(t.gas_price)),
+                gas: U256::from(t.gas_limit),
+                input: t.input.clone(),
+                chain_id: t.chain_id.map(U64::from),
+                signature: Some(Signature {
+                    r: t.signature().r(),
+                    s: t.signature().s(),
+                    v: U256::from(t.signature().v().y_parity_byte()),
+                    y_parity: None,
+                }),
+                access_list: None,
+                transaction_type: None,
+                max_fee_per_blob_gas: None,
+                blob_versioned_hashes: vec![],
+                other: Default::default(),
+            }
+        }
         TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::Eip2930(t)) => AlloyTransaction {
             hash,
             nonce: U64::from(t.nonce),

crates/anvil/src/eth/alloy_sign.rs

@@ -1,7 +1,7 @@
 use crate::eth::error::BlockchainError;
 
 use alloy_network::{Signed, Transaction};
-use alloy_primitives::{Address, Signature, U256};
+use alloy_primitives::{Address, Signature, B256, U256};
 use alloy_signer::{LocalWallet, Signer as AlloySigner, SignerSync as AlloySignerSync};
 use alloy_sol_types::Eip712Domain;
 use anvil_core::eth::transaction::{
@@ -31,6 +31,9 @@ pub trait Signer: Send + Sync {
         payload: &Eip712Domain,
     ) -> Result<Signature, BlockchainError>;
 
+    /// Signs the given hash.
+    async fn sign_hash(&self, address: Address, hash: B256) -> Result<Signature, BlockchainError>;
+
     /// signs a transaction request using the given account in request
     fn sign_transaction(
         &self,
@@ -79,6 +82,12 @@ impl Signer for DevSigner {
         // Ok(signer.sign_typed_data(payload).await?)
     }
 
+    async fn sign_hash(&self, address: Address, hash: B256) -> Result<Signature, BlockchainError> {
+        let signer = self.accounts.get(&address).ok_or(BlockchainError::NoSignerAvailable)?;
+
+        Ok(signer.sign_hash(hash).await?)
+    }
+
     fn sign_transaction(
         &self,
         request: TypedTransactionRequest,
@@ -106,15 +115,21 @@ pub fn build_typed_transaction(
     let tx = match request {
         TypedTransactionRequest::Legacy(tx) => {
             let sighash = tx.signature_hash();
-            TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::Legacy(Signed::new_unchecked(tx, signature, sighash)))
+            TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::Legacy(Signed::new_unchecked(
+                tx, signature, sighash,
+            )))
         }
         TypedTransactionRequest::EIP2930(tx) => {
             let sighash = tx.signature_hash();
-            TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::Eip2930(Signed::new_unchecked(tx, signature, sighash)))
+            TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::Eip2930(
+                Signed::new_unchecked(tx, signature, sighash),
+            ))
         }
         TypedTransactionRequest::EIP1559(tx) => {
             let sighash = tx.signature_hash();
-            TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::Eip1559(Signed::new_unchecked(tx, signature, sighash)))
+            TypedTransaction::Enveloped(alloy_consensus::TxEnvelope::Eip1559(
+                Signed::new_unchecked(tx, signature, sighash),
+            ))
         }
         TypedTransactionRequest::Deposit(tx) => {
             let DepositTransactionRequest {

crates/anvil/src/eth/api.rs

@@ -29,8 +29,9 @@ use crate::{
     revm::primitives::Output,
     ClientFork, LoggingManager, Miner, MiningMode, StorageInfo,
 };
-use alloy_consensus::{TxLegacy, TxEnvelope};
-use alloy_network::{Signed, TxKind};
+use alloy_consensus::TxEnvelope;
+use alloy_dyn_abi::TypedData;
+use alloy_network::TxKind;
 use alloy_primitives::{Address, Bytes, TxHash, B256, B64, U256, U64};
 use alloy_rlp::Decodable;
 use alloy_rpc_trace_types::{
@@ -60,7 +61,6 @@ use anvil_core::{
     },
 };
 use anvil_rpc::{error::RpcError, response::ResponseResult};
-use ethers::types::transaction::eip712::TypedData;
 use foundry_common::{provider::alloy::ProviderBuilder, types::ToEthers};
 use foundry_evm::{
     backend::DatabaseError,
@@ -831,12 +831,17 @@ impl EthApi {
     /// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md), and includes full support of arrays and recursive data structures.
     ///
     /// Handler for ETH RPC call: `eth_signTypedData_v4`
-    pub async fn sign_typed_data_v4(&self, _address: Address, _data: &TypedData) -> Result<String> {
+    pub async fn sign_typed_data_v4(&self, address: Address, data: &TypedData) -> Result<String> {
         node_info!("eth_signTypedData_v4");
-        todo!()
-        // let signer = self.get_signer(address).ok_or(BlockchainError::NoSignerAvailable)?;
-        // let signature = alloy_primitives::hex::encode(signer.sign_typed_data(address,
-        // data).await?.as_bytes()); Ok(format!("0x{signature}"))
+        let signer = self.get_signer(address).ok_or(BlockchainError::NoSignerAvailable)?;
+        let signature = signer
+            .sign_hash(
+                address,
+                data.eip712_signing_hash().map_err(|_| BlockchainError::NoSignerAvailable)?,
+            )
+            .await?;
+        let signature = alloy_primitives::hex::encode(signature.as_bytes());
+        Ok(format!("0x{signature}"))
     }
 
     /// The sign method calculates an Ethereum specific signature