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
@@ -198,7 +203,10 @@ 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" }
+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/", branch = "dani/coerce-str"}
+alloy-primitives = { git = "https://github.com/alloy-rs/core/", branch = "dani/coerce-str"}
+alloy-json-abi = { git = "https://github.com/alloy-rs/core/", branch = "dani/coerce-str"}
+alloy-sol-types = { git = "https://github.com/alloy-rs/core/", branch = "dani/coerce-str"}

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/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;
@@ -240,31 +242,31 @@ impl OtsInternalOperation {
             .arena
             .iter()
             .filter_map(|node| match (node.kind(), node.status()) {
-                (CallKind::Call, _) if !node.trace.value.is_zero() => Some(Self {
+                (CallKind::Call, _) if !node.trace.value == rU256::ZERO => Some(Self {
                     r#type: OtsInternalOperationType::Transfer,
-                    from: node.trace.caller,
-                    to: node.trace.address,
-                    value: node.trace.value,
+                    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: node.trace.address,
-                    value: node.trace.value,
+                    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: node.trace.address,
-                    value: node.trace.value,
+                    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,
+                        from: node.trace.address.to_ethers(),
                         // the foundry CallTraceNode doesn't have a refund address
                         to: Default::default(),
-                        value: node.trace.value,
+                        value: node.trace.value.to_ethers(),
                     })
                 }
                 _ => None,

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
+foundry-block-explorers.workspace = true
+
+
 chrono.workspace = true
 evm-disassembler = "0.2"
 eyre.workspace = true

crates/cast/bin/cmd/call.rs

@@ -1,18 +1,16 @@
 use cast::{Cast, TxBuilder};
 use clap::Parser;
-use ethers::{
-    solc::EvmVersion,
-    types::{BlockId, NameOrAddress, U256},
-};
+use ethers::types::{BlockId, NameOrAddress, U256};
 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>;
@@ -175,7 +173,7 @@ impl CallArgs {
             }
             _ => {
                 // fill first here because we need to use the builder in the conditional
-                fill_tx(&mut builder, tx.value, sig, args, data).await?;
+                fill_tx(&mut builder, tx.value.map(|t| t.to_ethers()), sig, args, data).await?;
 
                 if trace {
                     let figment = Config::figment_with_root(find_project_root_path(None).unwrap())
@@ -208,7 +206,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?);
@@ -225,7 +223,7 @@ async fn fill_create(
     sig: Option<String>,
     args: Vec<String>,
 ) -> Result<()> {
-    builder.value(value);
+    builder.value(value.map(|v| v.to_alloy()));
 
     let mut data = hex::decode(code)?;
 
@@ -247,7 +245,7 @@ async fn fill_tx(
     args: Vec<String>,
     data: Option<String>,
 ) -> Result<()> {
-    builder.value(value);
+    builder.value(value.map(|v| v.to_alloy()));
 
     if let Some(sig) = sig {
         builder.set_args(sig.as_str(), args).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,20 +1,21 @@
+use alloy_primitives::{Address, U256};
 use cast::{Cast, TxBuilder};
 use clap::Parser;
-use ethers::types::{NameOrAddress, U256};
 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`.
 #[derive(Debug, Parser)]
 pub struct EstimateArgs {
     /// The destination of the transaction.
-    #[clap(value_parser = NameOrAddress::from_str)]
-    to: Option<NameOrAddress>,
+    #[clap(value_parser = Address::from_str)]
+    to: Option<Address>,
 
     /// The signature of the function to call.
     sig: Option<String>,
@@ -26,11 +27,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 +86,9 @@ 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.map(|t| t.to_ethers()), chain, false)
+                .await?;
         builder.etherscan_api_key(api_key);
 
         match command {

crates/cast/bin/cmd/find_block.rs

@@ -1,9 +1,11 @@
+use alloy_primitives::{U256, U64};
 use cast::Cast;
 use clap::Parser;
-use ethers::prelude::*;
+use ethers_providers::Middleware;
 use eyre::Result;
 use foundry_cli::{opts::RpcOpts, utils};
 use foundry_config::Config;
+use foundry_utils::types::{ToAlloy, ToEthers};
 use futures::join;
 
 /// CLI arguments for `cast find-block`.
@@ -33,14 +35,14 @@ impl FindBlockArgs {
 
         let block_num = if ts_block_latest < ts_target {
             // If the most recent block's timestamp is below the target, return it
-            last_block_num
+            last_block_num.to_alloy()
         } else if ts_block_1 > ts_target {
             // If the target timestamp is below block 1's timestamp, return that
             U64::from(1_u64)
         } else {
             // Otherwise, find the block that is closest to the timestamp
             let mut low_block = U64::from(1_u64); // block 0 has a timestamp of 0: https://github.com/ethereum/go-ethereum/issues/17042#issuecomment-559414137
-            let mut high_block = last_block_num;
+            let mut high_block = last_block_num.to_alloy();
             let mut matching_block: Option<U64> = None;
             while high_block > low_block && matching_block.is_none() {
                 // Get timestamp of middle block (this approach approach to avoids overflow)
@@ -51,7 +53,7 @@ impl FindBlockArgs {
                     .checked_div(U64::from(2_u64))
                     .unwrap();
                 let mid_block = high_block.checked_sub(high_minus_low_over_2).unwrap();
-                let ts_mid_block = cast_provider.timestamp(mid_block).await?;
+                let ts_mid_block = cast_provider.timestamp(mid_block.to_ethers()).await?;
 
                 // Check if we've found a match or should keep searching
                 if ts_mid_block == ts_target {
@@ -60,8 +62,8 @@ impl FindBlockArgs {
                     // The target timestamp is in between these blocks. This rounds to the
                     // highest block if timestamp is equidistant between blocks
                     let res = join!(
-                        cast_provider.timestamp(high_block),
-                        cast_provider.timestamp(low_block)
+                        cast_provider.timestamp(high_block.to_ethers()),
+                        cast_provider.timestamp(low_block.to_ethers())
                     );
                     let ts_high = res.0.unwrap();
                     let ts_low = res.1.unwrap();