feat(deps): Move to Alloy ABI encoding/decoding & alloy types

Cargo.toml

@@ -159,6 +159,11 @@ alloy-json-abi = "0.4.1"
 alloy-sol-types = "0.4.1"
 syn-solidity = "0.4.1"
 
+# solc utils
+foundry-compilers = { version = "0.1", default-features = false }
+# block explorer utils
+foundry-block-explorers = { version = "0.1", default-features = false }
+
 solang-parser = "=0.3.2"
 
 ## misc
@@ -187,18 +192,21 @@ color-eyre = "0.6"
 #ethers-solc = { path = "../ethers-rs/ethers-solc" }
 
 [patch.crates-io]
-ethers = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-addressbook = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-core = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-contract = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-contract-abigen = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-providers = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-signers = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-middleware = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-etherscan = { git = "https://github.com/gakonst/ethers-rs" }
-ethers-solc = { git = "https://github.com/gakonst/ethers-rs" }
-
-# revm = { git = "https://github.com/bluealloy/revm/", branch = "main" }
-# revm-interpreter = { git = "https://github.com/bluealloy/revm/", branch = "main" }
-# revm-precompile = { git = "https://github.com/bluealloy/revm/", branch = "main" }
-# revm-primitives = { git = "https://github.com/bluealloy/revm/", branch = "main" }
+ethers = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-addressbook = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-core = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-contract = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-contract-abigen = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-providers = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-signers = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-middleware = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-etherscan = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+ethers-solc = { git = "https://github.com/gakonst/ethers-rs", rev = "9754f22d06a2defe5608c4c9b809cc361443a3dc" }
+
+foundry-compilers = { git = "https://github.com/foundry-rs/compilers" }
+foundry-block-explorers = { git = "https://github.com/foundry-rs/block-explorers"}
+
+alloy-dyn-abi = { git = "https://github.com/alloy-rs/core/" }
+alloy-primitives = { git = "https://github.com/alloy-rs/core/" }
+alloy-json-abi = { git = "https://github.com/alloy-rs/core/" }
+alloy-sol-types = { git = "https://github.com/alloy-rs/core/" }

crates/abi/Cargo.toml

@@ -21,4 +21,4 @@ foundry-macros.workspace = true
 
 ethers-core.workspace = true
 ethers-contract = { workspace = true, features = ["abigen", "providers"] }
-ethers-providers.workspace = true
+ethers-providers.workspace = true

crates/anvil/src/cmd.rs

@@ -188,7 +188,7 @@ impl NodeArgs {
                     .fork_block_number
                     .or_else(|| self.evm_opts.fork_url.as_ref().and_then(|f| f.block)),
             )
-            .with_fork_chain_id(self.evm_opts.fork_chain_id)
+            .with_fork_chain_id(self.evm_opts.fork_chain_id.map(u64::from))
             .fork_request_timeout(self.evm_opts.fork_request_timeout.map(Duration::from_millis))
             .fork_request_retries(self.evm_opts.fork_request_retries)
             .fork_retry_backoff(self.evm_opts.fork_retry_backoff.map(Duration::from_millis))

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

@@ -1158,7 +1158,7 @@ impl Backend {
                     (halt_to_instruction_result(reason), gas_used, None)
                 },
             };
-            let res = inspector.tracer.unwrap_or_default().traces.geth_trace(gas_used.into(), opts);
+            let res = inspector.tracer.unwrap_or_default().traces.geth_trace(rU256::from(gas_used), opts);
             trace!(target: "backend", "trace call return {:?} out: {:?} gas {} on block {}", exit_reason, out, gas_used, block_number);
             Ok(res)
         })

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

@@ -16,7 +16,7 @@ use ethers::{
     types::{ActionType, Bytes, GethDebugTracingOptions, TransactionReceipt, U256},
 };
 use foundry_evm::revm::{interpreter::InstructionResult, primitives::Env};
-use foundry_utils::types::ToEthers;
+use foundry_utils::types::{ToAlloy, ToEthers};
 use parking_lot::RwLock;
 use std::{
     collections::{HashMap, VecDeque},
@@ -406,7 +406,7 @@ impl MinedTransaction {
     }
 
     pub fn geth_trace(&self, opts: GethDebugTracingOptions) -> DefaultFrame {
-        self.info.traces.geth_trace(self.receipt.gas_used(), opts)
+        self.info.traces.geth_trace(self.receipt.gas_used().to_alloy(), opts)
     }
 }
 

crates/anvil/src/eth/otterscan/types.rs

@@ -1,7 +1,9 @@
+use alloy_primitives::U256 as rU256;
 use ethers::types::{
     Action, Address, Block, Bytes, CallType, Trace, Transaction, TransactionReceipt, H256, U256,
 };
 use foundry_evm::{executor::InstructionResult, CallKind};
+use foundry_utils::types::ToEthers;
 use futures::future::join_all;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_repr::Serialize_repr;
@@ -239,35 +241,37 @@ impl OtsInternalOperation {
             .traces
             .arena
             .iter()
-            .filter_map(|node| match (node.kind(), node.status()) {
-                (CallKind::Call, _) if !node.trace.value.is_zero() => Some(Self {
-                    r#type: OtsInternalOperationType::Transfer,
-                    from: node.trace.caller,
-                    to: node.trace.address,
-                    value: node.trace.value,
-                }),
-                (CallKind::Create, _) => Some(Self {
-                    r#type: OtsInternalOperationType::Create,
-                    from: node.trace.caller,
-                    to: node.trace.address,
-                    value: node.trace.value,
-                }),
-                (CallKind::Create2, _) => Some(Self {
-                    r#type: OtsInternalOperationType::Create2,
-                    from: node.trace.caller,
-                    to: node.trace.address,
-                    value: node.trace.value,
-                }),
-                (_, InstructionResult::SelfDestruct) => {
-                    Some(Self {
-                        r#type: OtsInternalOperationType::SelfDestruct,
-                        from: node.trace.address,
-                        // the foundry CallTraceNode doesn't have a refund address
-                        to: Default::default(),
-                        value: node.trace.value,
-                    })
+            .filter_map(|node| {
+                match (node.kind(), node.status()) {
+                    (CallKind::Call, _) if node.trace.value != rU256::ZERO => Some(Self {
+                        r#type: OtsInternalOperationType::Transfer,
+                        from: node.trace.caller.to_ethers(),
+                        to: node.trace.address.to_ethers(),
+                        value: node.trace.value.to_ethers(),
+                    }),
+                    (CallKind::Create, _) => Some(Self {
+                        r#type: OtsInternalOperationType::Create,
+                        from: node.trace.caller.to_ethers(),
+                        to: node.trace.address.to_ethers(),
+                        value: node.trace.value.to_ethers(),
+                    }),
+                    (CallKind::Create2, _) => Some(Self {
+                        r#type: OtsInternalOperationType::Create2,
+                        from: node.trace.caller.to_ethers(),
+                        to: node.trace.address.to_ethers(),
+                        value: node.trace.value.to_ethers(),
+                    }),
+                    (_, InstructionResult::SelfDestruct) => {
+                        Some(Self {
+                            r#type: OtsInternalOperationType::SelfDestruct,
+                            from: node.trace.address.to_ethers(),
+                            // the foundry CallTraceNode doesn't have a refund address
+                            to: Default::default(),
+                            value: node.trace.value.to_ethers(),
+                        })
+                    }
+                    _ => None,
                 }
-                _ => None,
             })
             .collect()
     }

crates/anvil/tests/it/fork.rs

@@ -15,7 +15,11 @@ use ethers::{
 };
 use foundry_common::get_http_provider;
 use foundry_config::Config;
-use foundry_utils::{rpc, rpc::next_http_rpc_endpoint, types::ToAlloy};
+use foundry_utils::{
+    rpc,
+    rpc::next_http_rpc_endpoint,
+    types::{ToAlloy, ToEthers},
+};
 use futures::StreamExt;
 use std::{sync::Arc, time::Duration};
 
@@ -160,8 +164,8 @@ async fn test_fork_eth_get_nonce() {
     }
 
     let addr = Config::DEFAULT_SENDER;
-    let api_nonce = api.transaction_count(addr, None).await.unwrap();
-    let provider_nonce = provider.get_transaction_count(addr, None).await.unwrap();
+    let api_nonce = api.transaction_count(addr.to_ethers(), None).await.unwrap();
+    let provider_nonce = provider.get_transaction_count(addr.to_ethers(), None).await.unwrap();
     assert_eq!(api_nonce, provider_nonce);
 }
 

crates/cast/Cargo.toml

@@ -27,6 +27,15 @@ foundry-common.workspace = true
 ethers-etherscan.workspace = true
 ethers-core.workspace = true
 ethers-providers.workspace = true
+
+alloy-primitives.workspace = true
+alloy-json-abi.workspace = true
+alloy-dyn-abi.workspace = true
+
+foundry-compilers = { workspace = true, default-features = false }
+foundry-block-explorers = { workspace = true }
+
+
 chrono.workspace = true
 evm-disassembler = "0.3"
 eyre.workspace = true

crates/cast/bin/cmd/access_list.rs

@@ -10,6 +10,7 @@ use foundry_cli::{
     utils,
 };
 use foundry_config::{Chain, Config};
+use foundry_utils::types::ToEthers;
 use std::str::FromStr;
 
 /// CLI arguments for `cast access-list`.
@@ -65,7 +66,8 @@ impl AccessListArgs {
         let chain = utils::get_chain(config.chain_id, &provider).await?;
         let sender = eth.wallet.sender().await;
 
-        access_list(&provider, sender, to, sig, args, data, tx, chain, block, to_json).await?;
+        access_list(&provider, sender.to_ethers(), to, sig, args, data, tx, chain, block, to_json)
+            .await?;
         Ok(())
     }
 }

crates/cast/bin/cmd/call.rs

@@ -1,18 +1,17 @@
+use alloy_primitives::U256;
 use cast::{Cast, TxBuilder};
 use clap::Parser;
-use ethers::{
-    solc::EvmVersion,
-    types::{BlockId, NameOrAddress, U256},
-};
+use ethers::types::{BlockId, NameOrAddress};
 use eyre::{Result, WrapErr};
 use foundry_cli::{
     opts::{EthereumOpts, TransactionOpts},
     utils::{self, handle_traces, parse_ether_value, TraceResult},
 };
 use foundry_common::runtime_client::RuntimeClient;
+use foundry_compilers::EvmVersion;
 use foundry_config::{find_project_root_path, Config};
 use foundry_evm::{executor::opts::EvmOpts, trace::TracingExecutor};
-use foundry_utils::types::ToAlloy;
+use foundry_utils::types::{ToAlloy, ToEthers};
 use std::str::FromStr;
 
 type Provider = ethers::providers::Provider<RuntimeClient>;
@@ -131,7 +130,7 @@ impl CallArgs {
         let sender = eth.wallet.sender().await;
 
         let mut builder: TxBuilder<'_, Provider> =
-            TxBuilder::new(&provider, sender, to, chain, tx.legacy).await?;
+            TxBuilder::new(&provider, sender.to_ethers(), to, chain, tx.legacy).await?;
 
         builder
             .gas(tx.gas_limit)
@@ -156,9 +155,9 @@ impl CallArgs {
                             .await;
 
                     let trace = match executor.deploy(
-                        sender.to_alloy(),
+                        sender,
                         code.into_bytes().into(),
-                        value.unwrap_or(U256::zero()).to_alloy(),
+                        value.unwrap_or(U256::ZERO),
                         None,
                     ) {
                         Ok(deploy_result) => TraceResult::from(deploy_result),
@@ -193,7 +192,7 @@ impl CallArgs {
                     let (tx, _) = builder.build();
 
                     let trace = TraceResult::from(executor.call_raw_committing(
-                        sender.to_alloy(),
+                        sender,
                         tx.to_addr().copied().expect("an address to be here").to_alloy(),
                         tx.data().cloned().unwrap_or_default().to_vec().into(),
                         tx.value().copied().unwrap_or_default().to_alloy(),
@@ -208,7 +207,7 @@ impl CallArgs {
 
         let builder_output: (
             ethers::types::transaction::eip2718::TypedTransaction,
-            Option<ethers::abi::Function>,
+            Option<alloy_json_abi::Function>,
         ) = builder.build();
 
         println!("{}", Cast::new(provider).call(builder_output, block).await?);

crates/cast/bin/cmd/create2.rs

@@ -1,10 +1,6 @@
+use alloy_primitives::{keccak256, Address, B256, U256};
 use cast::SimpleCast;
 use clap::Parser;
-use ethers::{
-    core::rand::thread_rng,
-    types::{Address, Bytes, H256, U256},
-    utils::{get_create2_address_from_hash, keccak256},
-};
 use eyre::{Result, WrapErr};
 use rayon::prelude::*;
 use regex::RegexSetBuilder;
@@ -114,7 +110,7 @@ impl Create2Args {
             let init_code_hash_bytes = hex::decode(init_code_hash)?;
             assert!(init_code_hash_bytes.len() == 32, "init code hash should be 32 bytes long");
             a.copy_from_slice(&init_code_hash_bytes);
-            a
+            a.into()
         } else {
             keccak256(hex::decode(init_code)?)
         };
@@ -124,14 +120,9 @@ impl Create2Args {
         let (salt, addr) = std::iter::repeat(())
             .par_bridge()
             .map(|_| {
-                let salt = H256::random_using(&mut thread_rng());
-                let salt = Bytes::from(salt.to_fixed_bytes());
+                let salt = B256::random();
 
-                let addr = SimpleCast::to_checksum_address(&get_create2_address_from_hash(
-                    deployer,
-                    salt.clone(),
-                    init_code_hash,
-                ));
+                let addr = SimpleCast::to_checksum_address(&deployer.create2(salt, init_code_hash));
 
                 (salt, addr)
             })
@@ -142,7 +133,7 @@ impl Create2Args {
             })
             .unwrap();
 
-        let salt = U256::from(salt.to_vec().as_slice());
+        let salt = U256::from_be_bytes(*salt);
         let address = Address::from_str(&addr).unwrap();
 
         println!(
@@ -165,8 +156,6 @@ fn get_regex_hex_string(s: String) -> Result<String> {
 
 #[cfg(test)]
 mod tests {
-    use ethers::{abi::AbiEncode, utils::get_create2_address};
-
     use super::*;
 
     const DEPLOYER: &str = "0x4e59b44847b379578588920ca78fbf26c0b4956c";
@@ -304,11 +293,12 @@ mod tests {
     }
 
     fn verify_create2(deployer: Address, salt: U256, init_code: Vec<u8>) -> Address {
-        // let init_code_hash = keccak256(init_code);
-        get_create2_address(deployer, salt.encode(), init_code)
+        let init_code_hash = keccak256(init_code);
+        deployer.create2(salt.to_be_bytes(), init_code_hash)
     }
 
     fn verify_create2_hash(deployer: Address, salt: U256, init_code_hash: Vec<u8>) -> Address {
-        get_create2_address_from_hash(deployer, salt.encode(), init_code_hash)
+        let init_code_hash = B256::from_slice(&init_code_hash);
+        deployer.create2(salt.to_be_bytes(), init_code_hash)
     }
 }

crates/cast/bin/cmd/estimate.rs

@@ -1,12 +1,14 @@
+use alloy_primitives::{Address, U256};
 use cast::{Cast, TxBuilder};
 use clap::Parser;
-use ethers::types::{NameOrAddress, U256};
+use ethers::types::NameOrAddress;
 use eyre::Result;
 use foundry_cli::{
     opts::{EtherscanOpts, RpcOpts},
     utils::{self, parse_ether_value},
 };
 use foundry_config::{figment::Figment, Config};
+use foundry_utils::types::ToEthers;
 use std::str::FromStr;
 
 /// CLI arguments for `cast estimate`.
@@ -26,11 +28,11 @@ pub struct EstimateArgs {
     #[clap(
         short,
         long,
-        value_parser = NameOrAddress::from_str,
+        value_parser = Address::from_str,
         default_value = "0x0000000000000000000000000000000000000000",
         env = "ETH_FROM",
     )]
-    from: NameOrAddress,
+    from: Address,
 
     /// Ether to send in the transaction.
     ///
@@ -85,7 +87,7 @@ impl EstimateArgs {
         let chain = utils::get_chain(config.chain_id, &provider).await?;
         let api_key = config.get_etherscan_api_key(Some(chain));
 
-        let mut builder = TxBuilder::new(&provider, from, to, chain, false).await?;
+        let mut builder = TxBuilder::new(&provider, from.to_ethers(), to, chain, false).await?;
         builder.etherscan_api_key(api_key);
 
         match command {