Solve workflow error

Author: Zyouell

mp2-common/src/eth.rs

@@ -716,9 +716,7 @@ mod tryethers {
     use eth_trie::{EthTrie, MemoryDB, Trie};
     use ethers::{
         providers::{Http, Middleware, Provider},
-        types::{
-            Block, BlockId, Bytes, EIP1186ProofResponse, Transaction, TransactionReceipt, H256, U64,
-        },
+        types::{BlockId, Bytes, Transaction, TransactionReceipt, U64},
     };
     use rlp::{Encodable, RlpStream};
 
@@ -866,9 +864,9 @@ mod test {
     use std::str::FromStr;
 
     use alloy::{
-        node_bindings::Anvil,
-        primitives::{Bytes, Log},
-        providers::{Provider, ProviderBuilder, WalletProvider},
+        network::TransactionBuilder,
+        primitives::{Bytes, Log, U256},
+        providers::{ext::AnvilApi, Provider, ProviderBuilder},
         rlp::Decodable,
         sol,
     };
@@ -1018,9 +1016,7 @@ mod test {
 
     #[tokio::test]
     async fn test_receipt_query() -> Result<()> {
-        let rpc = ProviderBuilder::new()
-            .with_recommended_fillers()
-            .on_anvil_with_wallet_and_config(|anvil| Anvil::block_time(anvil, 1));
+        let rpc = ProviderBuilder::new().on_anvil();
 
         // Make a contract that emits events so we can pick up on them
         sol! {
@@ -1053,28 +1049,30 @@ mod test {
 
         // Fire off a few transactions to emit some events
 
-        let address = rpc.default_signer_address();
-        let current_nonce = rpc.get_transaction_count(address).await?;
-
         let tx_reqs = (0..10)
             .map(|i| match i % 2 {
-                0 => contract
-                    .testEmit()
-                    .into_transaction_request()
-                    .nonce(current_nonce + i as u64),
-                1 => contract
-                    .twoEmits()
-                    .into_transaction_request()
-                    .nonce(current_nonce + i as u64),
+                0 => contract.testEmit().into_transaction_request(),
+                1 => contract.twoEmits().into_transaction_request(),
                 _ => unreachable!(),
             })
             .collect::<Vec<_>>();
         let mut join_set = JoinSet::new();
+
         tx_reqs.into_iter().for_each(|tx_req| {
             let rpc_clone = rpc.clone();
             join_set.spawn(async move {
                 rpc_clone
-                    .send_transaction(tx_req)
+                    .anvil_auto_impersonate_account(true)
+                    .await
+                    .unwrap();
+                let sender_address = Address::random();
+                let balance = U256::from(1e18 as u64);
+                rpc_clone
+                    .anvil_set_balance(sender_address, balance)
+                    .await
+                    .unwrap();
+                rpc_clone
+                    .send_transaction(tx_req.with_from(sender_address))
                     .await
                     .unwrap()
                     .watch()

mp2-test/src/mpt_sequential.rs

@@ -1,8 +1,8 @@
 use alloy::{
     eips::BlockNumberOrTag,
-    node_bindings::Anvil,
-    primitives::U256,
-    providers::{ext::AnvilApi, Provider, ProviderBuilder, WalletProvider},
+    network::TransactionBuilder,
+    primitives::{Address, U256},
+    providers::{ext::AnvilApi, Provider, ProviderBuilder},
     sol,
 };
 use eth_trie::{EthTrie, MemoryDB, Trie};
@@ -111,45 +111,39 @@ pub fn generate_receipt_proofs() -> Vec<ReceiptProofInfo> {
     rt.block_on(async {
         // Spin up a local node.
 
-        let rpc = ProviderBuilder::new()
-            .with_recommended_fillers()
-            .on_anvil_with_wallet_and_config(|a| Anvil::block_time(a, 1));
+        let rpc = ProviderBuilder::new().on_anvil();
 
         // Deploy the contract using anvil
         let event_contract = EventEmitter::deploy(rpc.clone()).await.unwrap();
 
         // Deploy the contract using anvil
         let other_contract = OtherEmitter::deploy(rpc.clone()).await.unwrap();
 
-        let address = rpc.default_signer_address();
-        rpc.anvil_set_nonce(address, U256::from(0)).await.unwrap();
         let tx_reqs = (0..25)
             .map(|i| match i % 4 {
-                0 => event_contract
-                    .testEmit()
-                    .into_transaction_request()
-                    .nonce(i as u64),
-                1 => event_contract
-                    .twoEmits()
-                    .into_transaction_request()
-                    .nonce(i as u64),
-                2 => other_contract
-                    .otherEmit()
-                    .into_transaction_request()
-                    .nonce(i as u64),
-                3 => other_contract
-                    .twoEmits()
-                    .into_transaction_request()
-                    .nonce(i as u64),
+                0 => event_contract.testEmit().into_transaction_request(),
+                1 => event_contract.twoEmits().into_transaction_request(),
+                2 => other_contract.otherEmit().into_transaction_request(),
+                3 => other_contract.twoEmits().into_transaction_request(),
                 _ => unreachable!(),
             })
             .collect::<Vec<_>>();
         let mut join_set = JoinSet::new();
         tx_reqs.into_iter().for_each(|tx_req| {
             let rpc_clone = rpc.clone();
             join_set.spawn(async move {
+                let sender_address = Address::random();
+                let funding = U256::from(1e18 as u64);
                 rpc_clone
-                    .send_transaction(tx_req)
+                    .anvil_set_balance(sender_address, funding)
+                    .await
+                    .unwrap();
+                rpc_clone
+                    .anvil_auto_impersonate_account(true)
+                    .await
+                    .unwrap();
+                rpc_clone
+                    .send_transaction(tx_req.with_from(sender_address))
                     .await
                     .unwrap()
                     .watch()