Merge branch 'master' into evalir/introduce-foundry-compilers

foundry-rs · Evalir · Oct 25, 2023 · Oct 5, 2023 · Oct 5, 2023 · Oct 6, 2023
commit bd2fbb36b97327197a0745dda2d3cfceda609880
@@ -206,11 +206,6 @@ ethers-solc = { git = "https://github.com/gakonst/ethers-rs" }
 foundry-compilers = {git = "https://github.com/foundry-rs/compilers"}
 foundry-block-explorers = {git = "https://github.com/foundry-rs/block-explorers"}
 
-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" }
-
 alloy-dyn-abi = { git = "https://github.com/alloy-rs/core/", branch = "main"}
 alloy-primitives = { git = "https://github.com/alloy-rs/core/", branch = "main"}
 alloy-json-abi = { git = "https://github.com/alloy-rs/core/", branch = "main"}

diff --git a/crates/abi/src/bindings/mod.rs b/crates/abi/src/bindings/mod.rs
@@ -7,6 +7,7 @@ use foundry_cli::{
     update_progress, utils,
     utils::{handle_traces, TraceResult},
 };
+use foundry_common::{is_known_system_sender, SYSTEM_TRANSACTION_TYPE};
 use foundry_compilers::EvmVersion;
 use foundry_config::{find_project_root_path, Config};
 use foundry_evm::{

@@ -1,10 +1,10 @@
 //! ABI related helper functions
-use alloy_json_abi::{Function, Event};
-use alloy_dyn_abi::{DynSolValue, DynSolType, JsonAbiExt, FunctionExt};
-use alloy_primitives::{Address, I256, U256, Log, hex};
+use alloy_dyn_abi::{DynSolType, DynSolValue, FunctionExt, JsonAbiExt};
+use alloy_json_abi::{Event, Function};
+use alloy_primitives::{hex, Address, Log, I256, U256};
 use ethers_core::types::Chain;
-use foundry_block_explorers::{contract::ContractMetadata, errors::EtherscanError, Client};
 use eyre::{ContextCompat, Result, WrapErr};
+use foundry_block_explorers::{contract::ContractMetadata, errors::EtherscanError, Client};
 use std::{future::Future, pin::Pin, str::FromStr};
 use yansi::Paint;
 
@@ -19,7 +19,10 @@ pub fn encode_function_args(func: &Function, args: &[impl AsRef<str>]) -> Result
         .zip(args)
         .map(|(input, arg)| (&input.ty, arg.as_ref()))
         .collect::<Vec<_>>();
-    let args = params.iter().map(|(_, arg)| DynSolValue::from(arg.to_owned().to_string())).collect::<Vec<_>>();
+    let args = params
+        .iter()
+        .map(|(_, arg)| DynSolValue::from(arg.to_owned().to_string()))
+        .collect::<Vec<_>>();
     Ok(func.abi_encode_input(&args)?)
 }
 
@@ -28,7 +31,12 @@ pub fn encode_function_args(func: &Function, args: &[impl AsRef<str>]) -> Result
 /// # Panics
 ///
 /// If the `sig` is an invalid function signature
-pub fn abi_decode_calldata(sig: &str, calldata: &str, input: bool, fn_selector: bool) -> Result<Vec<DynSolValue>> {
+pub fn abi_decode_calldata(
+    sig: &str,
+    calldata: &str,
+    input: bool,
+    fn_selector: bool,
+) -> Result<Vec<DynSolValue>> {
     let func = Function::parse(sig)?;
     let calldata = hex::decode(calldata)?;
     let res = if input {
@@ -51,53 +59,52 @@ pub fn abi_decode_calldata(sig: &str, calldata: &str, input: bool, fn_selector:
 }
 
 /// Parses string input as Token against the expected ParamType
-pub fn parse_tokens<'a, I: IntoIterator<Item = (&'a ParamType, &'a str)>>(
-    params: I,
-    lenient: bool,
-) -> Result<Vec<Token>> {
-    let mut tokens = Vec::new();
-
-    for (param, value) in params.into_iter() {
-        let mut token = if lenient {
-            LenientTokenizer::tokenize(param, value)
-        } else {
-            StrictTokenizer::tokenize(param, value)
-        };
-        if token.is_err() && value.starts_with("0x") {
-            match param {
-                ParamType::FixedBytes(32) => {
-                    if value.len() < 66 {
-                        let padded_value = [value, &"0".repeat(66 - value.len())].concat();
-                        token = if lenient {
-                            LenientTokenizer::tokenize(param, &padded_value)
-                        } else {
-                            StrictTokenizer::tokenize(param, &padded_value)
-                        };
-                    }
-                }
-                ParamType::Uint(_) => {
-                    // try again if value is hex
-                    if let Ok(value) = U256::from_str(value).map(|v| v.to_string()) {
-                        token = if lenient {
-                            LenientTokenizer::tokenize(param, &value)
-                        } else {
-                            StrictTokenizer::tokenize(param, &value)
-                        };
-                    }
-                }
-                // TODO: Not sure what to do here. Put the no effect in for now, but that is not
-                // ideal. We could attempt massage for every value type?
-                _ => {}
-            }
-        }
-
-        let token = token.map(sanitize_token).wrap_err_with(|| {
-            format!("Failed to parse `{value}`, expected value of type: {param}")
-        })?;
-        tokens.push(token);
-    }
-    Ok(tokens)
-}
+// pub fn parse_tokens<'a, I: IntoIterator<Item = (&'a ParamType, &'a str)>>(
+//     params: I,
+//     lenient: bool,
+// ) -> Result<Vec<Token>> { let mut tokens = Vec::new();
+
+//     for (param, value) in params.into_iter() {
+//         let mut token = if lenient {
+//             LenientTokenizer::tokenize(param, value)
+//         } else {
+//             StrictTokenizer::tokenize(param, value)
+//         };
+//         if token.is_err() && value.starts_with("0x") {
+//             match param {
+//                 ParamType::FixedBytes(32) => {
+//                     if value.len() < 66 {
+//                         let padded_value = [value, &"0".repeat(66 - value.len())].concat();
+//                         token = if lenient {
+//                             LenientTokenizer::tokenize(param, &padded_value)
+//                         } else {
+//                             StrictTokenizer::tokenize(param, &padded_value)
+//                         };
+//                     }
+//                 }
+//                 ParamType::Uint(_) => {
+//                     // try again if value is hex
+//                     if let Ok(value) = U256::from_str(value).map(|v| v.to_string()) {
+//                         token = if lenient {
+//                             LenientTokenizer::tokenize(param, &value)
+//                         } else {
+//                             StrictTokenizer::tokenize(param, &value)
+//                         };
+//                     }
+//                 }
+//                 // TODO: Not sure what to do here. Put the no effect in for now, but that is not
+//                 // ideal. We could attempt massage for every value type?
+//                 _ => {}
+//             }
+//         }
+
+//         let token = token.map(sanitize_token).wrap_err_with(|| {
+//             format!("Failed to parse `{value}`, expected value of type: {param}")
+//         })?;
+//         tokens.push(token);
+//     }
+//     Ok(tokens)
+// }
 
 /// Cleans up potential shortcomings of the ethabi Tokenizer.
 ///
@@ -172,8 +179,8 @@ pub fn format_token(param: &DynSolValue) -> String {
         DynSolValue::Tuple(tokens) => {
             let string = tokens.iter().map(format_token).collect::<Vec<String>>().join(", ");
             format!("({string})")
-        },
-        DynSolValue::Function(_) => unimplemented!()
+        }
+        _ => unimplemented!(),
     }
 }
 
@@ -251,8 +258,8 @@ pub fn get_func(sig: &str) -> Result<Function> {
     Ok(match Function::parse(sig) {
         Ok(func) => func,
         Err(err) => {
-                // we return the `Function` parse error as this case is more likely
-                return Err(err.into())
+            // we return the `Function` parse error as this case is more likely
+            return Err(err.into())
         }
     })
 }
@@ -268,8 +275,7 @@ pub fn get_indexed_event(mut event: Event, raw_log: &Log) -> Event {
     if !event.anonymous && raw_log.topics().len() > 1 {
         let indexed_params = raw_log.topics().len() - 1;
         let num_inputs = event.inputs.len();
-        let num_address_params =
-            event.inputs.iter().filter(|p| p.ty == "address").count();
+        let num_address_params = event.inputs.iter().filter(|p| p.ty == "address").count();
 
         event.inputs.iter_mut().enumerate().for_each(|(index, param)| {
             if param.name.is_empty() {
@@ -349,48 +355,48 @@ mod tests {
     use alloy_dyn_abi::EventExt;
     use alloy_primitives::B256;
 
-    #[test]
-    fn can_sanitize_token() {
-        let token =
-            Token::Array(LenientTokenizer::tokenize_array("[\"\"]", &ParamType::String).unwrap());
-        let sanitized = sanitize_token(token);
-        assert_eq!(sanitized, Token::Array(vec![Token::String("".to_string())]));
-
-        let token =
-            Token::Array(LenientTokenizer::tokenize_array("['']", &ParamType::String).unwrap());
-        let sanitized = sanitize_token(token);
-        assert_eq!(sanitized, Token::Array(vec![Token::String("".to_string())]));
-
-        let token = Token::Array(
-            LenientTokenizer::tokenize_array("[\"\",\"\"]", &ParamType::String).unwrap(),
-        );
-        let sanitized = sanitize_token(token);
-        assert_eq!(
-            sanitized,
-            Token::Array(vec![Token::String("".to_string()), Token::String("".to_string())])
-        );
-
-        let token =
-            Token::Array(LenientTokenizer::tokenize_array("['','']", &ParamType::String).unwrap());
-        let sanitized = sanitize_token(token);
-        assert_eq!(
-            sanitized,
-            Token::Array(vec![Token::String("".to_string()), Token::String("".to_string())])
-        );
-    }
-
-    #[test]
-    fn parse_hex_uint_tokens() {
-        let param = DynSolType::Uint(256);
-
-        let tokens = parse_tokens(std::iter::once((&param, "100")), true).unwrap();
-        assert_eq!(tokens, vec![DynSolValue::Uint(U256::from(100), 256)]);
-
-        let val: U256 = U256::from(100u64);
-        let hex_val = format!("0x{val:x}");
-        let tokens = parse_tokens(std::iter::once((&param, hex_val.as_str())), true).unwrap();
-        assert_eq!(tokens, vec![DynSolValue::Uint(U256::from(100), 256)]);
-    }
+    // #[test]
+    // fn can_sanitize_token() {
+    //     let token =
+    //         Token::Array(LenientTokenizer::tokenize_array("[\"\"]",
+    // &ParamType::String).unwrap());     let sanitized = sanitize_token(token);
+    //     assert_eq!(sanitized, Token::Array(vec![Token::String("".to_string())]));
+
+    //     let token =
+    //         Token::Array(LenientTokenizer::tokenize_array("['']", &ParamType::String).unwrap());
+    //     let sanitized = sanitize_token(token);
+    //     assert_eq!(sanitized, Token::Array(vec![Token::String("".to_string())]));
+
+    //     let token = Token::Array(
+    //         LenientTokenizer::tokenize_array("[\"\",\"\"]", &ParamType::String).unwrap(),
+    //     );
+    //     let sanitized = sanitize_token(token);
+    //     assert_eq!(
+    //         sanitized,
+    //         Token::Array(vec![Token::String("".to_string()), Token::String("".to_string())])
+    //     );
+
+    //     let token =
+    //         Token::Array(LenientTokenizer::tokenize_array("['','']",
+    // &ParamType::String).unwrap());     let sanitized = sanitize_token(token);
+    //     assert_eq!(
+    //         sanitized,
+    //         Token::Array(vec![Token::String("".to_string()), Token::String("".to_string())])
+    //     );
+    // }
+
+    // #[test]
+    // fn parse_hex_uint_tokens() {
+    //     let param = DynSolType::Uint(256);
+
+    //     let tokens = parse_tokens(std::iter::once((&param, "100")), true).unwrap();
+    //     assert_eq!(tokens, vec![DynSolValue::Uint(U256::from(100), 256)]);
+
+    //     let val: U256 = U256::from(100u64);
+    //     let hex_val = format!("0x{val:x}");
+    //     let tokens = parse_tokens(std::iter::once((&param, hex_val.as_str())), true).unwrap();
+    //     assert_eq!(tokens, vec![DynSolValue::Uint(U256::from(100), 256)]);
+    // }
 
     #[test]
     fn test_indexed_only_address() {
@@ -449,7 +455,9 @@ mod tests {
         // copied from testcases in https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1191.md
         let eip1191 = "0xFb6916095cA1Df60bb79ce92cE3EA74c37c5d359";
         assert_ne!(
-            format_token(&DynSolValue::Address(Address::from_str(&eip1191.to_lowercase()).unwrap())),
+            format_token(&DynSolValue::Address(
+                Address::from_str(&eip1191.to_lowercase()).unwrap()
+            )),
             eip1191.to_string()
         );
     }

@@ -13,7 +13,11 @@ where
         return U256::ZERO
     }
 
-    values.iter().copied().fold(U256::ZERO, |sum, val| sum + val.into()).div(U256::from(values.len()))
+    values
+        .iter()
+        .copied()
+        .fold(U256::ZERO, |sum, val| sum + val.into())
+        .div(U256::from(values.len()))
 }
 
 /// Returns the median of a _sorted_ slice
@@ -83,7 +87,15 @@ mod tests {
 
     #[test]
     fn calc_mean() {
-        let values = [U256::ZERO, U256::from(1), U256::from(2u64), U256::from(3u64), U256::from(4u64), U256::from(5u64), U256::from(6u64)];
+        let values = [
+            U256::ZERO,
+            U256::from(1),
+            U256::from(2u64),
+            U256::from(3u64),
+            U256::from(4u64),
+            U256::from(5u64),
+            U256::from(6u64),
+        ];
         let m = mean(&values);
         assert_eq!(m, U256::from(3u64));
     }

@@ -1,8 +1,8 @@
 //! Support for compiling [foundry_compilers::Project]
 use crate::{compact_to_contract, glob::GlobMatcher, term, TestFunctionExt};
 use comfy_table::{presets::ASCII_MARKDOWN, *};
-use foundry_block_explorers::contract::Metadata;
 use eyre::Result;
+use foundry_block_explorers::contract::Metadata;
 use foundry_compilers::{
     artifacts::{BytecodeObject, ContractBytecodeSome},
     remappings::Remapping,

@@ -255,7 +255,8 @@ impl ResolvedEtherscanConfig {
     /// `api_key` and cache
     pub fn into_client(
         self,
-    ) -> Result<foundry_block_explorers::Client, foundry_block_explorers::errors::EtherscanError> {
+    ) -> Result<foundry_block_explorers::Client, foundry_block_explorers::errors::EtherscanError>
+    {
         let ResolvedEtherscanConfig { api_url, browser_url, key: api_key, chain } = self;
         let (mainnet_api, mainnet_url) =
             ethers_core::types::Chain::Mainnet.etherscan_urls().expect("exist; qed");

@@ -3,10 +3,9 @@ use crate::{
     abi::ConsoleEvents::{self, *},
     executor::inspector::cheatcodes::util::MAGIC_SKIP_BYTES,
 };
-use alloy_dyn_abi::{JsonAbiExt, DynSolValue, DynSolType};
+use alloy_dyn_abi::{DynSolType, DynSolValue, JsonAbiExt};
 use alloy_json_abi::JsonAbi;
-use alloy_primitives::{B256, Bytes};
-use alloy_primitives::{Log as AlloyLog};
+use alloy_primitives::{Bytes, Log as AlloyLog, B256};
 use alloy_sol_types::{sol, SolEvent};
 use ethers::{
     abi::{decode, AbiDecode, Contract as Abi, ParamType, RawLog, Token},
@@ -55,7 +54,10 @@ pub fn decode_console_logs(logs: &[Log]) -> Vec<String> {
 /// This function returns [None] if it is not a DSTest log or the result of a Hardhat
 /// `console.log`.
 pub fn decode_console_log(log: &Log) -> Option<String> {
-    let raw_log = AlloyLog::new_unchecked(log.topics.into_iter().map(|h| h.to_alloy()).collect_vec(), log.data.0.into());
+    let raw_log = AlloyLog::new_unchecked(
+        log.topics.into_iter().map(|h| h.to_alloy()).collect_vec(),
+        log.data.0.into(),
+    );
     let data = log_address::abi_decode_data(&raw_log.data, false);
     if let Ok(inner) = log::abi_decode_data(&raw_log.data, false) {
         return Some(inner.0)
@@ -215,7 +217,8 @@ pub fn decode_revert(
                     if abi_error.signature()[..SELECTOR_LEN].as_bytes() == &err[..SELECTOR_LEN] {
                         // if we don't decode, don't return an error, try to decode as a
                         // string later
-                        if let Ok(decoded) = abi_error.abi_decode_input(&err[SELECTOR_LEN..], false) {
+                        if let Ok(decoded) = abi_error.abi_decode_input(&err[SELECTOR_LEN..], false)
+                        {
                             let inputs = decoded
                                 .iter()
                                 .map(foundry_common::abi::format_token)
@@ -306,7 +309,8 @@ pub fn decode_custom_error_args(err: &[u8], args: usize) -> Option<DynSolValue>
     // brute force decode all possible combinations
     for num in (2..=args).rev() {
         for candidate in TYPES.iter().cloned().combinations(num) {
-            if let Ok(decoded) = DynSolType::abi_decode_sequence( &DynSolType::Tuple(candidate), err) {
+            if let Ok(decoded) = DynSolType::abi_decode_sequence(&DynSolType::Tuple(candidate), err)
+            {
                 return Some(decoded)
             }
         }