Add alloy script for EOAMultisend

Author: 0xpantera

rs/Cargo.lock

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-alloy = { version = "0.15.11", features = ["full", "node-bindings"] }
+alloy = { version = "0.15.11", features = ["full", "node-bindings", "json"] }
+bytes = "1.10.1"
 eyre = "0.6.12"
-tokio = "1.45.0"
+tokio = { version = "1.45.0", features = ["rt-multi-thread", "macros"] }

rs/Cargo.toml

@@ -1,56 +1,120 @@
 use alloy::{
     eips::eip7702::Authorization,
-    network::{TransactionBuilder, TransactionBuilder7702, TxSigner},
-    node_bindings::Anvil,
-    primitives::{Address, U256, address},
+    network::{TransactionBuilder, TransactionBuilder7702},
+    primitives::{Address, Bytes, TxKind, U256, address},
     providers::{Provider, ProviderBuilder},
     rpc::types::TransactionRequest,
-    signers::{Signer, SignerSync, local::PrivateKeySigner},
+    signers::{SignerSync, local::PrivateKeySigner},
     sol,
 };
-use eyre::{ErrReport, Result};
+use bytes::{BufMut, BytesMut};
+use eyre::Result;
 use std::env;
 use std::str::FromStr;
 
 sol!(
+    #[allow(missing_docs)]
     #[sol(rpc)]
-    "../src/EOAMultisend.sol"
+    EOAMultisend,
+    "../out/EOAMultisend.sol/EOAMultisend.json"
 );
 
 async fn eoa_multisend(pk: PrivateKeySigner, calls: Vec<TransactionRequest>) -> Result<()> {
-    let sepolia = "https://sepolia.etherscan.io".parse()?;
+    let rpc_url = "https://sepolia.drpc.org".parse()?;
     let provider = ProviderBuilder::new()
         .wallet(pk.clone())
-        .connect_http(sepolia);
+        .connect_http(rpc_url);
 
-    // let contract = EOAMultisend::deploy(&provider).await?;
+    let contract = EOAMultisend::deploy(&provider).await?;
+
+    let authorization = Authorization {
+        chain_id: U256::from(11155111),
+        address: *contract.address(),
+        nonce: provider.get_transaction_count(pk.address()).await?,
+    };
+
+    let signature = pk.sign_hash_sync(&authorization.signature_hash())?;
+    let signed_authorization = authorization.into_signed(signature);
+
+    let batched = pack_multisend(&calls)?;
+
+    let call = contract.execute_0(batched);
+    let execute_calldata = call.calldata().to_owned();
+
+    let tx = TransactionRequest::default()
+        .with_to(pk.address())
+        .with_authorization_list(vec![signed_authorization])
+        .with_input(execute_calldata);
+
+    // Send the transaction and wait for the broadcast.
+    let pending_tx = provider.send_transaction(tx).await?;
+
+    println!("Pending transaction... {}", pending_tx.tx_hash());
+
+    let receipt = pending_tx.get_receipt().await?;
+
+    let etherscan_url = String::from("https://sepolia.etherscan.io/tx/");
+    println!(
+        "  Tx Receipt: {}",
+        etherscan_url + &receipt.transaction_hash.to_string()
+    );
 
-    // let authorization = Authorization {
-    //     chain_id: U256::from(11155111),
-    //     // Reference to the contract that will be set as code for the authority.
-    //     address: *contract.address(),
-    //     nonce: provider.get_transaction_count(pk.address()).await?,
-    // };
     Ok(())
 }
 
+/// Encode a list of EOA-style txs for MultiSend/MultiSendCallOnly.
+fn pack_multisend(calls: &[TransactionRequest]) -> eyre::Result<Bytes> {
+    let mut out = BytesMut::new();
+
+    for tx in calls {
+        // operation ─ normal CALL
+        out.put_u8(0);
+
+        // to ─ 20 bytes (error if missing)
+        let to = match tx.to.as_ref() {
+            Some(TxKind::Call(addr)) => addr,
+            _ => return Err(eyre::eyre!("Tx is missing `to` address")),
+        };
+        out.extend_from_slice(to.as_slice());
+
+        // value ─ 32 bytes big-endian
+        let value: U256 = tx.value.unwrap_or_default();
+        out.extend_from_slice(&value.to_be_bytes::<32>());
+
+        // data length & data
+        let data: Bytes = tx
+            .input
+            .input // first try the “input” field
+            .clone()
+            .or_else(|| tx.input.data.clone()) // else fall back to “data”
+            .unwrap_or_default(); // or empty
+        out.extend_from_slice(&U256::from(data.len()).to_be_bytes::<32>());
+        out.extend_from_slice(&data);
+    }
+
+    Ok(Bytes::from(out.freeze()))
+}
+
 #[tokio::main]
-fn main() -> Result<()> {
-    let anvil = Anvil::new().arg("--hardfork").arg("prague").try_spawn()?;
+async fn main() -> Result<()> {
     let private_key: PrivateKeySigner = match env::var("PK") {
         Ok(pk) => PrivateKeySigner::from_str(pk.as_str())?,
-        Err(_) => anvil.keys()[0].clone().into(),
+        Err(_) => PrivateKeySigner::from_str(
+            "0xe4dc8cbe94cbc139084c9c7adc5c2a829d3246f76282679e0c067147a47eb3f8",
+        )?,
     };
 
     let tx1 = TransactionRequest::default()
         .with_to(Address::ZERO)
-        .with_value(U256::from(10000000000000));
+        .with_value(U256::from(10000000000000_i64));
 
     let tx2 = TransactionRequest::default()
         .with_to(address!("0x1111111111111111111111111111111111111111"))
-        .with_value(U256::from(20000000000000));
+        .with_value(U256::from(20000000000000_i64));
 
     let calls = vec![tx1, tx2];
 
+    eoa_multisend(private_key, calls).await?;
+
     Ok(())
 }