Migrate evm_ (impersonate, automine, etc) APIs to alloy (#4004)

# Description
Discussed in this thread:
#4001 (comment)

This PR moves the impersonation mechanisms to alloy, the migrated ones
are only impersonated in the specific transaction, no changes to the
actual tests were needed.

Exposed the previous string oriented API under a trait to as discussed
in a comment below.
Anvil provides an anvil specific API that we're not using unless
necessary as these ones are more general

# Changes

- [ ] Migrate the last `mine_pending_block`
- [ ] Migrate the other evm calls to the new trait
- [ ] Migrate the last impersonations
- [ ] Remove the forked_node and local_node modules

## How to test
Existing tests

Author: jmg-duarte

crates/driver/src/tests/setup/blockchain.rs

@@ -24,7 +24,7 @@ use {
     },
     ethrpc::{
         Web3,
-        alloy::{CallBuilderExt, ProviderExt},
+        alloy::{CallBuilderExt, EvmProviderExt, ProviderExt},
     },
     futures::Future,
     solvers_dto::solution::Flashloan,
@@ -859,11 +859,7 @@ impl Blockchain {
     }
 
     pub async fn set_auto_mining(&self, enabled: bool) {
-        self.web3
-            .alloy
-            .raw_request::<_, ()>("evm_setAutomine".into(), (enabled,))
-            .await
-            .unwrap();
+        self.web3.alloy.evm_set_automine(enabled).await.unwrap();
     }
 }
 

crates/e2e/src/nodes/forked_node.rs

@@ -1,6 +1,3 @@
-pub mod forked_node;
-pub mod local_node;
-
 /// The default node URL that should be used for e2e tests.
 pub const NODE_HOST: &str = "http://127.0.0.1:8545";
 

crates/e2e/src/nodes/local_node.rs

@@ -1,12 +1,12 @@
 use {
-    crate::{
-        nodes::forked_node::ForkedNodeApi,
-        setup::{DeployedContracts, deploy::Contracts},
-    },
+    crate::setup::{DeployedContracts, deploy::Contracts},
     ::alloy::{
         network::{Ethereum, NetworkWallet, TransactionBuilder},
         primitives::{Address, U256},
-        providers::{Provider, ext::AnvilApi},
+        providers::{
+            Provider,
+            ext::{AnvilApi, ImpersonateConfig},
+        },
         rpc::types::TransactionRequest,
         signers::local::PrivateKeySigner,
     },
@@ -16,11 +16,7 @@ use {
         GPv2AllowListAuthentication::GPv2AllowListAuthentication,
         test::CowProtocolToken,
     },
-    ethrpc::alloy::{
-        CallBuilderExt,
-        ProviderSignerExt,
-        conversions::{IntoAlloy, IntoLegacy},
-    },
+    ethrpc::alloy::{CallBuilderExt, ProviderSignerExt},
     hex_literal::hex,
     model::{
         DomainSeparator,
@@ -283,22 +279,9 @@ impl OnchainComponents {
         with_wei: U256,
     ) -> [TestAccount; N] {
         let authenticator = &self.contracts.gp_authenticator;
+        let auth_manager = authenticator.manager().call().await.unwrap();
 
-        let auth_manager = authenticator.manager().call().await.unwrap().into_legacy();
-
-        let forked_node_api = self.web3.api::<ForkedNodeApi<_>>();
-
-        forked_node_api
-            .set_balance(&auth_manager, 100u64.eth().into_legacy())
-            .await
-            .expect("could not set auth_manager balance");
-
-        let impersonated_authenticator = {
-            forked_node_api
-                .impersonate(&auth_manager)
-                .await
-                .expect("could not impersonate auth_manager");
-
+        let gpv2_auth = {
             // we create a new provider without a wallet so that
             // alloy does not try to sign the tx with it and instead
             // forwards the tx to the node for signing. This will
@@ -310,21 +293,43 @@ impl OnchainComponents {
         let solvers = self.make_accounts::<N>(with_wei).await;
 
         for solver in &solvers {
-            impersonated_authenticator
-                .addSolver(solver.address())
-                .from(auth_manager.into_alloy())
-                .send_and_watch()
+            self.web3
+                .alloy
+                .anvil_send_impersonated_transaction_with_config(
+                    gpv2_auth
+                        .addSolver(solver.address())
+                        .from(auth_manager)
+                        .into_transaction_request(),
+                    ImpersonateConfig {
+                        fund_amount: Some(100u64.eth()),
+                        stop_impersonate: true,
+                    },
+                )
                 .await
-                .expect("failed to add solver");
+                .unwrap()
+                .watch()
+                .await
+                .unwrap();
         }
 
         if let Some(router) = &self.contracts.flashloan_router {
-            impersonated_authenticator
-                .addSolver(*router.address())
-                .from(auth_manager.into_alloy())
-                .send_and_watch()
+            self.web3
+                .alloy
+                .anvil_send_impersonated_transaction_with_config(
+                    gpv2_auth
+                        .addSolver(*router.address())
+                        .from(auth_manager)
+                        .into_transaction_request(),
+                    ImpersonateConfig {
+                        fund_amount: Some(100u64.eth()),
+                        stop_impersonate: true,
+                    },
+                )
                 .await
-                .expect("failed to add flashloan wrapper");
+                .unwrap()
+                .watch()
+                .await
+                .unwrap();
         }
 
         solvers

crates/e2e/src/nodes/mod.rs

@@ -1,8 +1,8 @@
 use {
     ::alloy::primitives::U256,
     driver::domain::eth::NonZeroU256,
-    e2e::{nodes::local_node::TestNodeApi, setup::*},
-    ethrpc::alloy::CallBuilderExt,
+    e2e::setup::*,
+    ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     model::{
         order::{OrderCreation, OrderKind},
         quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
@@ -57,8 +57,8 @@ async fn place_order_with_quote(web3: Web3) {
     services.start_protocol(solver.clone()).await;
 
     // Disable auto-mine so we don't accidentally mine a settlement
-    web3.api::<TestNodeApi<_>>()
-        .set_automine_enabled(false)
+    web3.alloy
+        .evm_set_automine(false)
         .await
         .expect("Must be able to disable automine");
 
@@ -140,8 +140,8 @@ async fn disabled_same_sell_and_buy_token_order_feature(web3: Web3) {
     services.start_protocol(solver.clone()).await;
 
     // Disable auto-mine so we don't accidentally mine a settlement
-    web3.api::<TestNodeApi<_>>()
-        .set_automine_enabled(false)
+    web3.alloy
+        .evm_set_automine(false)
         .await
         .expect("Must be able to disable automine");
 

crates/e2e/src/setup/onchain_components/mod.rs

@@ -1,9 +1,9 @@
 use {
     crate::ethflow::{EthFlowOrderOnchainStatus, ExtendedEthFlowOrder},
-    ::alloy::primitives::Address,
+    ::alloy::{primitives::Address, providers::ext::AnvilApi},
     chrono::{TimeZone, Utc},
-    e2e::{nodes::local_node::TestNodeApi, setup::*},
-    ethrpc::{Web3, block_stream::timestamp_of_current_block_in_seconds},
+    e2e::setup::*,
+    ethrpc::{Web3, alloy::EvmProviderExt, block_stream::timestamp_of_current_block_in_seconds},
     model::quote::{OrderQuoteRequest, OrderQuoteSide, QuoteSigningScheme, Validity},
     number::{nonzero::NonZeroU256, units::EthUnit},
     refunder::refund_service::RefundService,
@@ -106,16 +106,21 @@ async fn refunder_tx(web3: Web3) {
     .unwrap();
 
     let time_after_expiration = valid_to as i64 + 60;
-    web3.api::<TestNodeApi<_>>()
-        .set_next_block_timestamp(
-            &Utc.timestamp_millis_opt(time_after_expiration * 1_000)
-                .unwrap(),
+    web3.alloy
+        .evm_set_next_block_timestamp(
+            u64::try_from(
+                Utc.timestamp_millis_opt(time_after_expiration * 1_000)
+                    .unwrap()
+                    .timestamp(),
+            )
+            .expect("timestamp should be positive"),
         )
         .await
         .expect("Must be able to set block timestamp");
+
     // mine next block to push time forward
-    web3.api::<TestNodeApi<_>>()
-        .mine_pending_block()
+    web3.alloy
+        .evm_mine(None)
         .await
         .expect("Unable to mine next block");
 

crates/e2e/tests/e2e/place_order_with_quote.rs

@@ -1,7 +1,7 @@
 use {
     ::alloy::primitives::U256,
-    e2e::{nodes::local_node::TestNodeApi, setup::*},
-    ethrpc::alloy::CallBuilderExt,
+    e2e::setup::*,
+    ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     model::{
         order::{OrderCreation, OrderCreationAppData, OrderKind, OrderStatus},
         signature::EcdsaSigningScheme,
@@ -105,10 +105,7 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) {
         .unwrap();
 
     // disable auto mining to prevent order being immediately executed
-    web3.api::<TestNodeApi<_>>()
-        .set_automine_enabled(false)
-        .await
-        .unwrap();
+    web3.alloy.evm_set_automine(false).await.unwrap();
 
     // Place Orders
     let services = Services::new(&onchain).await;
@@ -181,8 +178,8 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) {
     assert_eq!(error_message, expected_body);
 
     // Continue automining so our order can be executed
-    web3.api::<TestNodeApi<_>>()
-        .set_automine_enabled(true)
+    web3.alloy
+        .evm_set_automine(true)
         .await
         .expect("Must be able to disable auto-mining");