feat(anvil): added anvil_impersonateSignature (#11195)

* wip

* wip

* wip

* wip

* test

* clippy

* fixes

* removed checks

* extra check

Author: Soubhik-10

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

@@ -321,6 +321,11 @@ pub enum EthRequest {
         with = "sequence"
     )]
     AutoImpersonateAccount(bool),
+
+    /// Registers a signature/address pair for faking `ecrecover` results
+    #[serde(rename = "anvil_impersonateSignature", with = "sequence")]
+    ImpersonateSignature(Bytes, Address),
+
     /// Returns true if automatic mining is enabled, and false.
     #[serde(rename = "anvil_getAutomine", alias = "hardhat_getAutomine", with = "empty_params")]
     GetAutoMine(()),

crates/anvil/src/eth/api.rs

@@ -349,6 +349,9 @@ impl EthApi {
             EthRequest::AutoImpersonateAccount(enable) => {
                 self.anvil_auto_impersonate_account(enable).await.to_rpc_result()
             }
+            EthRequest::ImpersonateSignature(signature, address) => {
+                self.anvil_impersonate_signature(signature, address).await.to_rpc_result()
+            }
             EthRequest::GetAutoMine(()) => self.anvil_get_auto_mine().to_rpc_result(),
             EthRequest::Mine(blocks, interval) => {
                 self.anvil_mine(blocks, interval).await.to_rpc_result()
@@ -1821,6 +1824,16 @@ impl EthApi {
         Ok(())
     }
 
+    /// Registers a new address and signature pair to impersonate.
+    pub async fn anvil_impersonate_signature(
+        &self,
+        signature: Bytes,
+        address: Address,
+    ) -> Result<()> {
+        node_info!("anvil_impersonateSignature");
+        self.backend.impersonate_signature(signature, address).await
+    }
+
     /// Returns true if auto mining is enabled, and false.
     ///
     /// Handler for ETH RPC call: `anvil_getAutomine`

crates/anvil/src/eth/backend/cheats.rs

@@ -1,7 +1,15 @@
 //! Support for "cheat codes" / bypass functions
 
-use alloy_primitives::{Address, map::AddressHashSet};
+use alloy_evm::precompiles::{Precompile, PrecompileInput};
+use alloy_primitives::{
+    Address, Bytes,
+    map::{AddressHashSet, foldhash::HashMap},
+};
 use parking_lot::RwLock;
+use revm::precompile::{
+    PrecompileError, PrecompileOutput, PrecompileResult, secp256k1::ec_recover_run,
+    utilities::right_pad,
+};
 use std::sync::Arc;
 
 /// Manages user modifications that may affect the node's behavior
@@ -61,6 +69,21 @@ impl CheatsManager {
     pub fn impersonated_accounts(&self) -> AddressHashSet {
         self.state.read().impersonated_accounts.clone()
     }
+
+    /// Registers an override so that `ecrecover(signature)` returns `addr`.
+    pub fn add_recover_override(&self, sig: Bytes, addr: Address) {
+        self.state.write().signature_overrides.insert(sig, addr);
+    }
+
+    /// If an override exists for `sig`, returns the address; otherwise `None`.
+    pub fn get_recover_override(&self, sig: &Bytes) -> Option<Address> {
+        self.state.read().signature_overrides.get(sig).copied()
+    }
+
+    /// Returns true if any ecrecover overrides have been registered.
+    pub fn has_recover_overrides(&self) -> bool {
+        !self.state.read().signature_overrides.is_empty()
+    }
 }
 
 /// Container type for all the state variables
@@ -70,4 +93,47 @@ pub struct CheatsState {
     pub impersonated_accounts: AddressHashSet,
     /// If set to true will make the `is_impersonated` function always return true
     pub auto_impersonate_accounts: bool,
+    /// Overrides for ecrecover: Signature => Address
+    pub signature_overrides: HashMap<Bytes, Address>,
+}
+
+impl CheatEcrecover {
+    pub fn new(cheats: Arc<CheatsManager>) -> Self {
+        Self { cheats }
+    }
+}
+
+impl Precompile for CheatEcrecover {
+    fn call(&self, input: PrecompileInput<'_>) -> PrecompileResult {
+        if !self.cheats.has_recover_overrides() {
+            return ec_recover_run(input.data, input.gas);
+        }
+
+        const ECRECOVER_BASE: u64 = 3_000;
+        if input.gas < ECRECOVER_BASE {
+            return Err(PrecompileError::OutOfGas);
+        }
+        let padded = right_pad::<128>(input.data);
+        let v = padded[63];
+        let mut sig_bytes = [0u8; 65];
+        sig_bytes[..64].copy_from_slice(&padded[64..128]);
+        sig_bytes[64] = v;
+        let sig_bytes_wrapped = Bytes::copy_from_slice(&sig_bytes);
+        if let Some(addr) = self.cheats.get_recover_override(&sig_bytes_wrapped) {
+            let mut out = [0u8; 32];
+            out[12..].copy_from_slice(addr.as_slice());
+            return Ok(PrecompileOutput::new(ECRECOVER_BASE, Bytes::copy_from_slice(&out)));
+        }
+        ec_recover_run(input.data, input.gas)
+    }
+
+    fn is_pure(&self) -> bool {
+        false
+    }
+}
+
+/// A custom ecrecover precompile that supports cheat-based signature overrides.
+#[derive(Clone, Debug)]
+pub struct CheatEcrecover {
+    cheats: Arc<CheatsManager>,
 }

crates/anvil/src/eth/backend/mem/mod.rs

@@ -7,7 +7,7 @@ use crate::{
     config::PruneStateHistoryConfig,
     eth::{
         backend::{
-            cheats::CheatsManager,
+            cheats::{CheatEcrecover, CheatsManager},
             db::{Db, MaybeFullDatabase, SerializableState},
             env::Env,
             executor::{ExecutedTransactions, TransactionExecutor},
@@ -45,7 +45,7 @@ use alloy_evm::{
     Database, Evm,
     eth::EthEvmContext,
     overrides::{OverrideBlockHashes, apply_state_overrides},
-    precompiles::PrecompilesMap,
+    precompiles::{DynPrecompile, Precompile, PrecompilesMap},
 };
 use alloy_network::{
     AnyHeader, AnyRpcBlock, AnyRpcHeader, AnyRpcTransaction, AnyTxEnvelope, AnyTxType,
@@ -98,7 +98,7 @@ use foundry_evm::{
     traces::{CallTraceDecoder, TracingInspectorConfig},
     utils::{get_blob_base_fee_update_fraction, get_blob_base_fee_update_fraction_by_spec_id},
 };
-use foundry_evm_core::either_evm::EitherEvm;
+use foundry_evm_core::{either_evm::EitherEvm, precompiles::EC_RECOVER};
 use futures::channel::mpsc::{UnboundedSender, unbounded};
 use op_alloy_consensus::DEPOSIT_TX_TYPE_ID;
 use op_revm::{
@@ -1181,6 +1181,14 @@ impl Backend {
             inject_precompiles(&mut evm, factory.precompiles());
         }
 
+        let cheats = Arc::new(self.cheats.clone());
+        if cheats.has_recover_overrides() {
+            let cheat_ecrecover = CheatEcrecover::new(Arc::clone(&cheats));
+            evm.precompiles_mut().apply_precompile(&EC_RECOVER, move |_| {
+                Some(DynPrecompile::new_stateful(move |input| cheat_ecrecover.call(input)))
+            });
+        }
+
         evm
     }
 
@@ -3137,6 +3145,16 @@ impl Backend {
         Ok(None)
     }
 
+    /// Overrides the given signature to impersonate the specified address during ecrecover.
+    pub async fn impersonate_signature(
+        &self,
+        signature: Bytes,
+        address: Address,
+    ) -> Result<(), BlockchainError> {
+        self.cheats.add_recover_override(signature, address);
+        Ok(())
+    }
+
     /// Prove an account's existence or nonexistence in the state trie.
     ///
     /// Returns a merkle proof of the account's trie node, `account_key` == keccak(address)

crates/anvil/src/evm.rs

@@ -1,13 +1,13 @@
-use std::fmt::Debug;
-
 use alloy_evm::{
     Database, Evm,
     eth::EthEvmContext,
     precompiles::{DynPrecompile, PrecompileInput, PrecompilesMap},
 };
+
 use foundry_evm_core::either_evm::EitherEvm;
 use op_revm::OpContext;
 use revm::{Inspector, precompile::PrecompileWithAddress};
+use std::fmt::Debug;
 
 /// Object-safe trait that enables injecting extra precompiles when using
 /// `anvil` as a library.

crates/anvil/tests/it/anvil.rs

@@ -3,8 +3,10 @@
 use alloy_consensus::EMPTY_ROOT_HASH;
 use alloy_eips::BlockNumberOrTag;
 use alloy_hardforks::EthereumHardfork;
-use alloy_primitives::Address;
+use alloy_network::{ReceiptResponse, TransactionBuilder};
+use alloy_primitives::{Address, B256, hex};
 use alloy_provider::Provider;
+use alloy_rpc_types::TransactionRequest;
 use anvil::{NodeConfig, spawn};
 
 #[tokio::test(flavor = "multi_thread")]
@@ -135,3 +137,36 @@ async fn test_can_use_default_genesis_block_number() {
 
     assert_eq!(0, provider.get_block(0.into()).await.unwrap().unwrap().header.number);
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_anvil_recover_signature() {
+    let (api, handle) = spawn(NodeConfig::test()).await;
+    let provider = handle.http_provider();
+    alloy_sol_types::sol! {
+    #[sol(rpc)]
+        contract TestRecover {
+            function testRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s, address expected) external pure {
+                address recovered = ecrecover(hash, v, r, s);
+                require(recovered == expected, "ecrecover failed: address mismatch");
+            }
+        }
+    }
+    let bytecode = hex::decode(
+        "0x60808060405234601557610125908161001a8239f35b5f80fdfe60808060405260043610156011575f80fd5b5f3560e01c63bff0b743146023575f80fd5b3460eb5760a036600319011260eb5760243560ff811680910360eb576084356001600160a01b038116929083900360eb5760805f916020936004358252848201526044356040820152606435606082015282805260015afa1560e0575f516001600160a01b031603609057005b60405162461bcd60e51b815260206004820152602260248201527f65637265636f766572206661696c65643a2061646472657373206d69736d61746044820152610c6d60f31b6064820152608490fd5b6040513d5f823e3d90fd5b5f80fdfea264697066735822122006368b42bca31c97f2c409a1cc5186dc899d4255ecc28db7bbb0ad285dc82ae464736f6c634300081c0033",
+    ).unwrap();
+
+    let tx = TransactionRequest::default().with_deploy_code(bytecode);
+    let receipt = provider.send_transaction(tx.into()).await.unwrap().get_receipt().await.unwrap();
+    let contract_address = receipt.contract_address().unwrap();
+    let contract = TestRecover::new(contract_address, &provider);
+
+    let sig = alloy_primitives::hex::decode("11".repeat(65)).unwrap();
+    let r = B256::from_slice(&sig[0..32]);
+    let s = B256::from_slice(&sig[32..64]);
+    let v = sig[64];
+    let fake_hash = B256::random();
+    let expected = alloy_primitives::address!("0x1234567890123456789012345678901234567890");
+    api.anvil_impersonate_signature(sig.clone().into(), expected).await.unwrap();
+    let result = contract.testRecover(fake_hash, v, r, s, expected).call().await;
+    assert!(result.is_ok(), "ecrecover failed: {:?}", result.err());
+}