chore: extract fetch_abi_from_etherscan and use &Config (#11426)

Author: DaniPopes

crates/cast/src/cmd/artifact.rs

@@ -1,6 +1,6 @@
 use super::{
     creation_code::{fetch_creation_code_from_etherscan, parse_code_output},
-    interface::{fetch_abi_from_etherscan, load_abi_from_file},
+    interface::load_abi_from_file,
 };
 use alloy_primitives::Address;
 use alloy_provider::Provider;
@@ -10,10 +10,12 @@ use foundry_cli::{
     opts::{EtherscanOpts, RpcOpts},
     utils::{self, LoadConfig},
 };
-use foundry_common::fs;
+use foundry_common::{abi::fetch_abi_from_etherscan, fs};
 use serde_json::json;
 use std::path::PathBuf;
 
+foundry_config::impl_figment_convert!(ArtifactArgs, etherscan, rpc);
+
 /// CLI arguments for `cast artifact`.
 #[derive(Parser)]
 pub struct ArtifactArgs {
@@ -45,24 +47,25 @@ pub struct ArtifactArgs {
 
 impl ArtifactArgs {
     pub async fn run(self) -> Result<()> {
-        let Self { contract, mut etherscan, rpc, output: output_location, abi_path } = self;
+        let mut config = self.load_config()?;
+
+        let Self { contract, output: output_location, abi_path, etherscan: _, rpc: _ } = self;
 
-        let config = rpc.load_config()?;
         let provider = utils::get_provider(&config)?;
         let chain = provider.get_chain_id().await?;
-        etherscan.chain = Some(chain.into());
+        config.chain = Some(chain.into());
 
         let abi = if let Some(ref abi_path) = abi_path {
             load_abi_from_file(abi_path, None)?
         } else {
-            fetch_abi_from_etherscan(contract, &etherscan).await?
+            fetch_abi_from_etherscan(contract, &config).await?
         };
 
         let (abi, _) = abi.first().ok_or_else(|| eyre::eyre!("No ABI found"))?;
 
-        let bytecode = fetch_creation_code_from_etherscan(contract, &etherscan, provider).await?;
+        let bytecode = fetch_creation_code_from_etherscan(contract, &config, provider).await?;
         let bytecode =
-            parse_code_output(bytecode, contract, &etherscan, abi_path.as_deref(), true, false)
+            parse_code_output(bytecode, contract, &config, abi_path.as_deref(), true, false)
                 .await?;
 
         let artifact = json!({

crates/cast/src/cmd/constructor_args.rs

@@ -1,7 +1,4 @@
-use super::{
-    creation_code::fetch_creation_code_from_etherscan,
-    interface::{fetch_abi_from_etherscan, load_abi_from_file},
-};
+use super::{creation_code::fetch_creation_code_from_etherscan, interface::load_abi_from_file};
 use alloy_dyn_abi::DynSolType;
 use alloy_primitives::{Address, Bytes};
 use alloy_provider::Provider;
@@ -11,6 +8,10 @@ use foundry_cli::{
     opts::{EtherscanOpts, RpcOpts},
     utils::{self, LoadConfig},
 };
+use foundry_common::abi::fetch_abi_from_etherscan;
+use foundry_config::Config;
+
+foundry_config::impl_figment_convert!(ConstructorArgsArgs, etherscan, rpc);
 
 /// CLI arguments for `cast creation-args`.
 #[derive(Parser)]
@@ -32,16 +33,16 @@ pub struct ConstructorArgsArgs {
 
 impl ConstructorArgsArgs {
     pub async fn run(self) -> Result<()> {
-        let Self { contract, mut etherscan, rpc, abi_path } = self;
+        let mut config = self.load_config()?;
+
+        let Self { contract, abi_path, etherscan: _, rpc: _ } = self;
 
-        let config = rpc.load_config()?;
         let provider = utils::get_provider(&config)?;
-        let chain = provider.get_chain_id().await?;
-        etherscan.chain = Some(chain.into());
+        config.chain = Some(provider.get_chain_id().await?.into());
 
-        let bytecode = fetch_creation_code_from_etherscan(contract, &etherscan, provider).await?;
+        let bytecode = fetch_creation_code_from_etherscan(contract, &config, provider).await?;
 
-        let args_arr = parse_constructor_args(bytecode, contract, &etherscan, abi_path).await?;
+        let args_arr = parse_constructor_args(bytecode, contract, &config, abi_path).await?;
         for arg in args_arr {
             let _ = sh_println!("{arg}");
         }
@@ -54,13 +55,13 @@ impl ConstructorArgsArgs {
 async fn parse_constructor_args(
     bytecode: Bytes,
     contract: Address,
-    etherscan: &EtherscanOpts,
+    config: &Config,
     abi_path: Option<String>,
 ) -> Result<Vec<String>> {
     let abi = if let Some(abi_path) = abi_path {
         load_abi_from_file(&abi_path, None)?
     } else {
-        fetch_abi_from_etherscan(contract, etherscan).await?
+        fetch_abi_from_etherscan(contract, config).await?
     };
 
     let abi = abi.into_iter().next().ok_or_eyre("No ABI found.")?;

crates/cast/src/cmd/creation_code.rs

@@ -1,4 +1,4 @@
-use super::interface::{fetch_abi_from_etherscan, load_abi_from_file};
+use super::interface::load_abi_from_file;
 use crate::SimpleCast;
 use alloy_consensus::Transaction;
 use alloy_primitives::{Address, Bytes};
@@ -11,7 +11,10 @@ use foundry_cli::{
     opts::{EtherscanOpts, RpcOpts},
     utils::{self, LoadConfig},
 };
-use foundry_common::provider::RetryProvider;
+use foundry_common::{abi::fetch_abi_from_etherscan, provider::RetryProvider};
+use foundry_config::Config;
+
+foundry_config::impl_figment_convert!(CreationCodeArgs, etherscan, rpc);
 
 /// CLI arguments for `cast creation-code`.
 #[derive(Parser)]
@@ -45,20 +48,21 @@ pub struct CreationCodeArgs {
 
 impl CreationCodeArgs {
     pub async fn run(self) -> Result<()> {
-        let Self { contract, mut etherscan, rpc, disassemble, without_args, only_args, abi_path } =
+        let mut config = self.load_config()?;
+
+        let Self { contract, disassemble, without_args, only_args, abi_path, etherscan: _, rpc: _ } =
             self;
 
-        let config = rpc.load_config()?;
         let provider = utils::get_provider(&config)?;
         let chain = provider.get_chain_id().await?;
-        etherscan.chain = Some(chain.into());
+        config.chain = Some(chain.into());
 
-        let bytecode = fetch_creation_code_from_etherscan(contract, &etherscan, provider).await?;
+        let bytecode = fetch_creation_code_from_etherscan(contract, &config, provider).await?;
 
         let bytecode = parse_code_output(
             bytecode,
             contract,
-            &etherscan,
+            &config,
             abi_path.as_deref(),
             without_args,
             only_args,
@@ -82,7 +86,7 @@ impl CreationCodeArgs {
 pub async fn parse_code_output(
     bytecode: Bytes,
     contract: Address,
-    etherscan: &EtherscanOpts,
+    config: &Config,
     abi_path: Option<&str>,
     without_args: bool,
     only_args: bool,
@@ -94,7 +98,7 @@ pub async fn parse_code_output(
     let abi = if let Some(abi_path) = abi_path {
         load_abi_from_file(abi_path, None)?
     } else {
-        fetch_abi_from_etherscan(contract, etherscan).await?
+        fetch_abi_from_etherscan(contract, config).await?
     };
 
     let abi = abi.into_iter().next().ok_or_eyre("No ABI found.")?;
@@ -131,10 +135,9 @@ pub async fn parse_code_output(
 /// Fetches the creation code of a contract from Etherscan and RPC.
 pub async fn fetch_creation_code_from_etherscan(
     contract: Address,
-    etherscan: &EtherscanOpts,
+    config: &Config,
     provider: RetryProvider,
 ) -> Result<Bytes> {
-    let config = etherscan.load_config()?;
     let chain = config.chain.unwrap_or_default();
     let api_version = config.get_etherscan_api_version(Some(chain));
     let api_key = config.get_etherscan_api_key(Some(chain)).unwrap_or_default();

crates/cast/src/cmd/interface.rs

@@ -2,10 +2,10 @@ use alloy_json_abi::{ContractObject, JsonAbi};
 use alloy_primitives::Address;
 use clap::Parser;
 use eyre::{Context, Result};
-use foundry_block_explorers::Client;
 use foundry_cli::{opts::EtherscanOpts, utils::LoadConfig};
 use foundry_common::{
     ContractsByArtifact,
+    abi::fetch_abi_from_etherscan,
     compile::{PathOrContractInfo, ProjectCompiler},
     find_target_path, fs, shell,
 };
@@ -65,7 +65,7 @@ impl InterfaceArgs {
             load_abi_from_file(&contract, name)?
         } else {
             match Address::from_str(&contract) {
-                Ok(address) => fetch_abi_from_etherscan(address, &etherscan).await?,
+                Ok(address) => fetch_abi_from_etherscan(address, &etherscan.load_config()?).await?,
                 Err(_) => load_abi_from_artifact(&contract)?,
             }
         };
@@ -137,20 +137,6 @@ fn load_abi_from_artifact(path_or_contract: &str) -> Result<Vec<(JsonAbi, String
     Ok(vec![(abi.clone(), contract.name().unwrap_or(name).to_string())])
 }
 
-/// Fetches the ABI of a contract from Etherscan.
-pub async fn fetch_abi_from_etherscan(
-    address: Address,
-    etherscan: &EtherscanOpts,
-) -> Result<Vec<(JsonAbi, String)>> {
-    let config = etherscan.load_config()?;
-    let chain = config.chain.unwrap_or_default();
-    let api_version = config.get_etherscan_api_version(Some(chain));
-    let api_key = config.get_etherscan_api_key(Some(chain)).unwrap_or_default();
-    let client = Client::new_with_api_version(chain, api_key, api_version)?;
-    let source = client.contract_source_code(address).await?;
-    source.items.into_iter().map(|item| Ok((item.abi()?, item.contract_name))).collect()
-}
-
 /// Converts a vector of tuples containing the ABI and contract name into a vector of
 /// `InterfaceSource` objects.
 fn get_interfaces(abis: Vec<(JsonAbi, String)>) -> Result<Vec<InterfaceSource>> {

crates/common/src/abi.rs

@@ -1,7 +1,7 @@
 //! ABI related helper functions.
 
 use alloy_dyn_abi::{DynSolType, DynSolValue, FunctionExt, JsonAbiExt};
-use alloy_json_abi::{Error, Event, Function, Param};
+use alloy_json_abi::{Error, Event, Function, JsonAbi, Param};
 use alloy_primitives::{Address, LogData, hex};
 use eyre::{Context, ContextCompat, Result};
 use foundry_block_explorers::{
@@ -137,6 +137,19 @@ pub fn get_indexed_event(mut event: Event, raw_log: &LogData) -> Event {
     event
 }
 
+/// Fetches the ABI of a contract from Etherscan.
+pub async fn fetch_abi_from_etherscan(
+    address: Address,
+    config: &foundry_config::Config,
+) -> Result<Vec<(JsonAbi, String)>> {
+    let chain = config.chain.unwrap_or_default();
+    let api_version = config.get_etherscan_api_version(Some(chain));
+    let api_key = config.get_etherscan_api_key(Some(chain)).unwrap_or_default();
+    let client = Client::new_with_api_version(chain, api_key, api_version)?;
+    let source = client.contract_source_code(address).await?;
+    source.items.into_iter().map(|item| Ok((item.abi()?, item.contract_name))).collect()
+}
+
 /// Given a function name, address, and args, tries to parse it as a `Function` by fetching the
 /// abi from etherscan. If the address is a proxy, fetches the ABI of the implementation contract.
 pub async fn get_func_etherscan(

crates/common/src/contracts.rs

@@ -566,6 +566,7 @@ pub fn find_matching_contract_artifact(
         Ok(artifact.clone())
     }
 }
+
 #[cfg(test)]
 mod tests {
     use super::*;