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

crates/evm/src/executor/backend/mod.rs

@@ -10,11 +10,10 @@ use crate::{
     },
     CALLER, TEST_CONTRACT_ADDRESS,
 };
-use alloy_primitives::{b256, Address, B256, U256, U64};
+use alloy_primitives::{b256, Address, B256, U256, U64, keccak256};
 use ethers::{
     prelude::Block,
     types::{BlockNumber, Transaction},
-    utils::keccak256,
 };
 use foundry_utils::types::{ToAlloy, ToEthers};
 pub use in_memory_db::MemDb;

crates/evm/src/executor/fork/backend.rs

@@ -3,12 +3,11 @@ use crate::executor::{
     backend::error::{DatabaseError, DatabaseResult},
     fork::{cache::FlushJsonBlockCacheDB, BlockchainDb},
 };
-use alloy_primitives::{Address, Bytes, B256, U256};
+use alloy_primitives::{Address, Bytes, B256, U256, keccak256};
 use ethers::{
     core::abi::ethereum_types::BigEndianHash,
     providers::Middleware,
     types::{Block, BlockId, NameOrAddress, Transaction},
-    utils::keccak256,
 };
 use foundry_common::NON_ARCHIVE_NODE_WARNING;
 use foundry_utils::types::{ToAlloy, ToEthers};

crates/evm/src/executor/fork/multi.rs

@@ -7,7 +7,6 @@ use crate::executor::fork::{
     BackendHandler, BlockchainDb, BlockchainDbMeta, CreateFork, SharedBackend,
 };
 use ethers::{
-    abi::{AbiDecode, AbiEncode, AbiError},
     providers::Provider,
     types::{BlockId, BlockNumber},
 };
@@ -49,18 +48,6 @@ impl<T: Into<String>> From<T> for ForkId {
     }
 }
 
-impl AbiEncode for ForkId {
-    fn encode(self) -> Vec<u8> {
-        AbiEncode::encode(self.0)
-    }
-}
-
-impl AbiDecode for ForkId {
-    fn decode(bytes: impl AsRef<[u8]>) -> Result<Self, AbiError> {
-        Ok(Self(String::decode(bytes)?))
-    }
-}
-
 /// The Sender half of multi fork pair.
 /// Can send requests to the `MultiForkHandler` to create forks
 #[derive(Debug, Clone)]

crates/evm/src/trace/decoder.rs

@@ -9,11 +9,9 @@ use crate::{
     trace::{node::CallTraceNode, utils},
     CALLER, TEST_CONTRACT_ADDRESS,
 };
-use alloy_primitives::FixedBytes;
-use ethers::{
-    abi::{Abi, Address, Event, Function, Param, ParamType, Token},
-    types::{H160, H256},
-};
+use alloy_primitives::{Address, FixedBytes, B256};
+use alloy_dyn_abi::{DynSolType, DynSolValue};
+use alloy_json_abi::{JsonAbi as Abi, Event, Function, Param};
 use foundry_common::{abi::get_indexed_event, SELECTOR_LEN};
 use foundry_utils::types::ToEthers;
 use hashbrown::HashSet;
@@ -47,7 +45,7 @@ impl CallTraceDecoderBuilder {
         for event in events {
             self.decoder
                 .events
-                .entry((event.signature(), indexed_inputs(&event)))
+                .entry((event.selector(), indexed_inputs(&event)))
                 .or_default()
                 .push(event);
         }
@@ -97,7 +95,7 @@ pub struct CallTraceDecoder {
     /// A mapping of signatures to their known functions
     pub functions: BTreeMap<FixedBytes<4>, Vec<Function>>,
     /// All known events
-    pub events: BTreeMap<(H256, usize), Vec<Event>>,
+    pub events: BTreeMap<(B256, usize), Vec<Event>>,
     /// All known errors
     pub errors: Abi,
     /// A signature identifier for events and functions.
@@ -110,17 +108,15 @@ pub struct CallTraceDecoder {
 macro_rules! precompiles {
     ($($number:literal : $name:ident($( $name_in:ident : $in:expr ),* $(,)?) -> ($( $name_out:ident : $out:expr ),* $(,)?)),+ $(,)?) => {{
         use std::string::String as RustString;
-        use ParamType::*;
         [$(
             (
-                H160([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, $number]),
+                Address::new([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, $number]),
                 #[allow(deprecated)]
                 Function {
                     name: RustString::from(stringify!($name)),
-                    inputs: vec![$(Param { name: RustString::from(stringify!($name_in)), kind: $in, internal_type: None, }),*],
-                    outputs: vec![$(Param { name: RustString::from(stringify!($name_out)), kind: $out, internal_type: None, }),*],
-                    constant: None,
-                    state_mutability: ethers::abi::StateMutability::Pure,
+                    inputs: vec![$(Param { name: RustString::from(stringify!($name_in)), ty: $in, components: vec![], internal_type: None, }),*],
+                    outputs: vec![$(Param { name: RustString::from(stringify!($name_out)), ty: $out, components: vec![], internal_type: None, }),*],
+                    state_mutability: alloy_json_abi::StateMutability::Pure,
                 },
             ),
         )+]
@@ -144,25 +140,25 @@ impl CallTraceDecoder {
             // TODO: These are the Ethereum precompiles. We should add a way to support precompiles
             // for other networks, too.
             precompiles: precompiles!(
-                0x01: ecrecover(hash: FixedBytes(32), v: Uint(256), r: Uint(256), s: Uint(256)) -> (publicAddress: Address),
-                0x02: sha256(data: Bytes) -> (hash: FixedBytes(32)),
-                0x03: ripemd(data: Bytes) -> (hash: FixedBytes(32)),
-                0x04: identity(data: Bytes) -> (data: Bytes),
-                0x05: modexp(Bsize: Uint(256), Esize: Uint(256), Msize: Uint(256), BEM: Bytes) -> (value: Bytes),
-                0x06: ecadd(x1: Uint(256), y1: Uint(256), x2: Uint(256), y2: Uint(256)) -> (x: Uint(256), y: Uint(256)),
-                0x07: ecmul(x1: Uint(256), y1: Uint(256), s: Uint(256)) -> (x: Uint(256), y: Uint(256)),
-                0x08: ecpairing(x1: Uint(256), y1: Uint(256), x2: Uint(256), y2: Uint(256), x3: Uint(256), y3: Uint(256)) -> (success: Uint(256)),
-                0x09: blake2f(rounds: Uint(4), h: FixedBytes(64), m: FixedBytes(128), t: FixedBytes(16), f: FixedBytes(1)) -> (h: FixedBytes(64)),
+                0x01: ecrecover(hash: format!("bytes32"), v: format!("uint256"), r: format!("uint256"), s: format!("uint256")) -> (publicAddress: format!("address")),
+                0x02: sha256(data: format!("bytes")) -> (hash: format!("bytes32")),
+                0x03: ripemd(data: format!("bytes")) -> (hash: format!("bytes32")),
+                0x04: identity(data: format!("bytes")) -> (data: format!("bytes")),
+                0x05: modexp(Bsize: format!("uint256"), Esize: format!("uint256"), Msize: format!("uint256"), BEM: format!("bytes")) -> (value: format!("bytes")),
+                0x06: ecadd(x1: format!("uint256"), y1: format!("uint256"), x2: format!("uint256"), y2: format!("uint256")) -> (x: format!("uint256"), y: format!("uint256")),
+                0x07: ecmul(x1: format!("uint256"), y1: format!("uint256"), s: format!("uint256")) -> (x: format!("uint256"), y: format!("uint256")),
+                0x08: ecpairing(x1: format!("uint256"), y1: format!("uint256"), x2: format!("uint256"), y2: format!("uint256"), x3: format!("uint256"), y3: format!("uint256")) -> (success: Uint(256)),
+                0x09: blake2f(rounds: DynSolType::Uint(4).to_string(), h: DynSolType::FixedBytes(64).to_string(), m: DynSolType::FixedBytes(128).to_string(), t: DynSolType::FixedBytes(16).to_string(), f: DynSolType::FixedBytes(1).to_string()) -> (h: DynSolType::FixedBytes(64).to_string()),
             ).into(),
 
             contracts: Default::default(),
 
             labels: [
-                (CHEATCODE_ADDRESS.to_ethers(), "VM".to_string()),
-                (HARDHAT_CONSOLE_ADDRESS.to_ethers(), "console".to_string()),
-                (DEFAULT_CREATE2_DEPLOYER.to_ethers(), "Create2Deployer".to_string()),
-                (CALLER.to_ethers(), "DefaultSender".to_string()),
-                (TEST_CONTRACT_ADDRESS.to_ethers(), "DefaultTestContract".to_string()),
+                (CHEATCODE_ADDRESS, "VM".to_string()),
+                (HARDHAT_CONSOLE_ADDRESS, "console".to_string()),
+                (DEFAULT_CREATE2_DEPLOYER, "Create2Deployer".to_string()),
+                (CALLER, "DefaultSender".to_string()),
+                (TEST_CONTRACT_ADDRESS, "DefaultTestContract".to_string()),
             ]
             .into(),
 

crates/evm/src/trace/mod.rs

@@ -2,11 +2,8 @@ use crate::{
     abi::CHEATCODE_ADDRESS, debug::Instruction, trace::identifier::LocalTraceIdentifier, CallKind,
 };
 pub use decoder::{CallTraceDecoder, CallTraceDecoderBuilder};
-use ethers::{
-    abi::{ethereum_types::BigEndianHash, Address, RawLog},
-    core::utils::to_checksum,
-    types::{Bytes, DefaultFrame, GethDebugTracingOptions, StructLog, H256, U256},
-};
+use ethers::types::{DefaultFrame, GethDebugTracingOptions, StructLog};
+use alloy_primitives::{Address, B256, U256, Log as RawLog, Bytes};
 pub use executor::TracingExecutor;
 use foundry_common::contracts::{ContractsByAddress, ContractsByArtifact};
 use foundry_utils::types::{ToAlloy, ToEthers};
@@ -97,7 +94,7 @@ impl CallTraceArena {
     // Recursively fill in the geth trace by going through the traces
     fn add_to_geth_trace(
         &self,
-        storage: &mut HashMap<Address, BTreeMap<H256, H256>>,
+        storage: &mut HashMap<Address, BTreeMap<B256, B256>>,
         trace_node: &CallTraceNode,
         struct_logs: &mut Vec<StructLog>,
         opts: &GethDebugTracingOptions,
@@ -111,7 +108,7 @@ impl CallTraceArena {
             if !opts.disable_storage.unwrap_or_default() {
                 let contract_storage = storage.entry(step.contract).or_default();
                 if let Some((key, value)) = step.state_diff {
-                    contract_storage.insert(H256::from_uint(&key), H256::from_uint(&value));
+                    contract_storage.insert(B256::from(key), B256::from(value));
                     log.storage = Some(contract_storage.clone());
                 }
             }
@@ -275,7 +272,7 @@ impl fmt::Display for RawOrDecodedLog {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             RawOrDecodedLog::Raw(log) => {
-                for (i, topic) in log.topics.iter().enumerate() {
+                for (i, topic) in log.topics().iter().enumerate() {
                     writeln!(
                         f,
                         "{:>13}: {}",
@@ -505,7 +502,7 @@ impl Default for CallTrace {
 
 impl fmt::Display for CallTrace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let address = to_checksum(&self.address, None);
+        let address = self.address.to_checksum(None);
         if self.created() {
             write!(
                 f,
@@ -543,7 +540,7 @@ impl fmt::Display for CallTrace {
                 self.gas_cost,
                 color.paint(self.label.as_ref().unwrap_or(&address)),
                 color.paint(func),
-                if !self.value.is_zero() {
+                if !self.value == U256::ZERO {
                     format!("{{value: {}}}", self.value)
                 } else {
                     "".to_string()
@@ -593,7 +590,7 @@ impl TraceKind {
 
 /// Chooses the color of the trace depending on the destination address and status of the call.
 fn trace_color(trace: &CallTrace) -> Color {
-    if trace.address == CHEATCODE_ADDRESS.to_ethers() {
+    if trace.address == CHEATCODE_ADDRESS {
         Color::Blue
     } else if trace.success {
         Color::Green
@@ -619,7 +616,7 @@ pub fn load_contracts(
         .iter()
         .filter_map(|(addr, name)| {
             if let Ok(Some((_, (abi, _)))) = contracts.find_by_name_or_identifier(name) {
-                return Some(((*addr).to_alloy(), (name.clone(), abi.clone())))
+                return Some((*addr, (name.clone(), abi.clone())))
             }
             None
         })

crates/evm/src/trace/node.rs

@@ -7,12 +7,11 @@ use crate::{
     },
     CallKind,
 };
-use ethers::{
-    abi::{Abi, Function},
-    types::{Action, Address, Call, CallResult, Create, CreateResult, Res, Suicide},
-};
+use alloy_dyn_abi::{JsonAbiExt, FunctionExt};
+use ethers::types::{Action, Call, CallResult, Create, CreateResult, Res, Suicide};
+use alloy_primitives::Address;
+use alloy_json_abi::{JsonAbi as Abi, Function};
 use foundry_common::SELECTOR_LEN;
-use foundry_utils::types::ToEthers;
 use revm::interpreter::InstructionResult;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -110,19 +109,19 @@ impl CallTraceNode {
 
         if let RawOrDecodedCall::Raw(ref bytes) = self.trace.data {
             let inputs = if bytes.len() >= SELECTOR_LEN {
-                if self.trace.address == CHEATCODE_ADDRESS.to_ethers() {
+                if self.trace.address == CHEATCODE_ADDRESS {
                     // Try to decode cheatcode inputs in a more custom way
                     utils::decode_cheatcode_inputs(func, bytes, errors, verbosity).unwrap_or_else(
                         || {
-                            func.decode_input(&bytes[SELECTOR_LEN..])
+                            func.abi_decode_input(&bytes[SELECTOR_LEN..], false)
                                 .expect("bad function input decode")
                                 .iter()
                                 .map(|token| utils::label(token, labels))
                                 .collect()
                         },
                     )
                 } else {
-                    match func.decode_input(&bytes[SELECTOR_LEN..]) {
+                    match func.abi_decode_input(&bytes[SELECTOR_LEN..], false) {
                         Ok(v) => v.iter().map(|token| utils::label(token, labels)).collect(),
                         Err(_) => Vec::new(),
                     }
@@ -137,7 +136,7 @@ impl CallTraceNode {
 
             if let RawOrDecodedReturnData::Raw(bytes) = &self.trace.output {
                 if !bytes.is_empty() && self.trace.success {
-                    if self.trace.address == CHEATCODE_ADDRESS.to_ethers() {
+                    if self.trace.address == CHEATCODE_ADDRESS {
                         if let Some(decoded) = funcs
                             .iter()
                             .find_map(|func| decode_cheatcode_outputs(func, bytes, verbosity))
@@ -148,7 +147,7 @@ impl CallTraceNode {
                     }
 
                     if let Some(tokens) =
-                        funcs.iter().find_map(|func| func.decode_output(bytes).ok())
+                        funcs.iter().find_map(|func| func.abi_decode_output(bytes, false).ok())
                     {
                         // Functions coming from an external database do not have any outputs
                         // specified, and will lead to returning an empty list of tokens.
@@ -183,15 +182,15 @@ impl CallTraceNode {
             self.trace.data = RawOrDecodedCall::Decoded(
                 precompile_fn.name.clone(),
                 precompile_fn.signature(),
-                precompile_fn.decode_input(bytes).map_or_else(
+                precompile_fn.abi_decode_input(bytes, false).map_or_else(
                     |_| vec![hex::encode(bytes)],
                     |tokens| tokens.iter().map(|token| utils::label(token, labels)).collect(),
                 ),
             );
 
             if let RawOrDecodedReturnData::Raw(ref bytes) = self.trace.output {
                 self.trace.output = RawOrDecodedReturnData::Decoded(
-                    precompile_fn.decode_output(bytes).map_or_else(
+                    precompile_fn.abi_decode_output(bytes, false).map_or_else(
                         |_| hex::encode(bytes),
                         |tokens| {
                             tokens

crates/evm/src/trace/utils.rs

@@ -1,22 +1,21 @@
 //! utilities used within tracing
 
 use crate::decode;
-use ethers::{
-    abi::{Abi, Address, Function, ParamType, Token},
-    core::utils::to_checksum,
-};
+use alloy_primitives::Address;
+use alloy_json_abi::{JsonAbi as Abi, Function};
+use alloy_dyn_abi::{DynSolValue, DynSolType, JsonAbiExt};
 use foundry_common::{abi::format_token, SELECTOR_LEN};
 use std::collections::HashMap;
 
-/// Returns the label for the given `token`
+/// Returns the label for the given [DynSolValue]
 ///
 /// If the `token` is an `Address` then we look abel the label map.
 /// by default the token is formatted using standard formatting
-pub fn label(token: &Token, labels: &HashMap<Address, String>) -> String {
+pub fn label(token: &DynSolValue, labels: &HashMap<Address, String>) -> String {
     match token {
-        Token::Address(addr) => {
+        DynSolValue::Address(addr) => {
             if let Some(label) = labels.get(addr) {
-                format!("{label}: [{}]", to_checksum(addr, None))
+                format!("{label}: [{}]", addr.to_checksum(None))
             } else {
                 format_token(token)
             }
@@ -39,7 +38,8 @@ pub(crate) fn decode_cheatcode_inputs(
         "rememberKey" | "addr" | "startBroadcast" | "broadcast" => {
             // these functions accept a private key as uint256, which should not be
             // converted to plain text
-            if !func.inputs.is_empty() && matches!(&func.inputs[0].kind, ParamType::Uint(_)) {
+            let expected_type = DynSolType::Uint(256).to_string();
+            if !func.inputs.is_empty() && matches!(&func.inputs[0].ty, expected_type) {
                 // redact private key input
                 Some(vec!["<pk>".to_string()])
             } else {
@@ -48,9 +48,10 @@ pub(crate) fn decode_cheatcode_inputs(
         }
         "sign" => {
             // sign(uint256,bytes32)
-            let mut decoded = func.decode_input(&data[SELECTOR_LEN..]).ok()?;
-            if !decoded.is_empty() && matches!(&func.inputs[0].kind, ParamType::Uint(_)) {
-                decoded[0] = Token::String("<pk>".to_string());
+            let mut decoded = func.abi_decode_input(&data[SELECTOR_LEN..], false).ok()?;
+            let expected_type = DynSolType::Uint(256).to_string();
+            if !decoded.is_empty() && matches!(&func.inputs[0].ty, expected_type) {
+                decoded[0] = DynSolValue::String("<pk>".to_string());
             }
             Some(decoded.iter().map(format_token).collect())
         }
@@ -82,14 +83,14 @@ pub(crate) fn decode_cheatcode_inputs(
             if verbosity >= 5 {
                 None
             } else {
-                let mut decoded = func.decode_input(&data[SELECTOR_LEN..]).ok()?;
+                let mut decoded = func.abi_decode_input(&data[SELECTOR_LEN..], false).ok()?;
                 let token =
                     if func.name.as_str() == "parseJson" || func.name.as_str() == "keyExists" {
                         "<JSON file>"
                     } else {
                         "<stringified JSON>"
                     };
-                decoded[0] = Token::String(token.to_string());
+                decoded[0] = DynSolValue::String(token.to_string());
                 Some(decoded.iter().map(format_token).collect())
             }
         }