Simplify Etherscan provider option, default v2

Author: grandizzy

crates/cli/src/opts/rpc.rs

@@ -114,6 +114,11 @@ pub struct EtherscanOpts {
     #[serde(rename = "etherscan_api_key", skip_serializing_if = "Option::is_none")]
     pub key: Option<String>,
 
+    /// The Etherscan API version.
+    #[arg(short, long = "etherscan-api-version", env = "ETHERSCAN_API_VERSION")]
+    #[serde(rename = "etherscan_api_version", skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<String>,
+
     /// The chain name or EIP-155 chain ID.
     #[arg(
         short,
@@ -154,6 +159,11 @@ impl EtherscanOpts {
         if let Some(key) = self.key() {
             dict.insert("etherscan_api_key".into(), key.into());
         }
+
+        if let Some(api_version) = &self.api_version {
+            dict.insert("etherscan_api_version".into(), api_version.to_string().into());
+        }
+
         if let Some(chain) = self.chain {
             if let ChainKind::Id(id) = chain.kind() {
                 dict.insert("chain_id".into(), (*id).into());

crates/config/src/etherscan.rs

@@ -58,6 +58,9 @@ pub enum EtherscanConfigError {
 
     #[error("At least one of `url` or `chain` must be present{0}")]
     MissingUrlOrChain(String),
+
+    #[error("Invalid Etherscan API version {0}")]
+    InvalidApiVersion(String),
 }
 
 /// Container type for Etherscan API keys and URLs.
@@ -194,7 +197,7 @@ impl EtherscanConfig {
     ) -> Result<ResolvedEtherscanConfig, EtherscanConfigError> {
         let Self { chain, mut url, key, api_version } = self;
 
-        let api_version_string = api_version.map(|v| v.to_string());
+        let api_version = api_version.unwrap_or(EtherscanApiVersion::V2);
 
         if let Some(url) = &mut url {
             *url = interpolate(url)?;
@@ -225,12 +228,12 @@ impl EtherscanConfig {
         match (chain, url) {
             (Some(chain), Some(api_url)) => Ok(ResolvedEtherscanConfig {
                 api_url,
-                api_version: api_version_string,
+                api_version,
                 browser_url: chain.etherscan_urls().map(|(_, url)| url.to_string()),
                 key,
                 chain: Some(chain),
             }),
-            (Some(chain), None) => ResolvedEtherscanConfig::create(key, chain, api_version_string)
+            (Some(chain), None) => ResolvedEtherscanConfig::create(key, chain, api_version)
                 .ok_or_else(|| {
                     let msg = alias.map(|a| format!(" `{a}`")).unwrap_or_default();
                     EtherscanConfigError::UnknownChain(msg, chain)
@@ -240,7 +243,7 @@ impl EtherscanConfig {
                 browser_url: None,
                 key,
                 chain: None,
-                api_version: api_version_string,
+                api_version,
             }),
             (None, None) => {
                 let msg = alias
@@ -264,8 +267,8 @@ pub struct ResolvedEtherscanConfig {
     /// The resolved API key.
     pub key: String,
     /// Etherscan API Version.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub api_version: Option<String>,
+    #[serde(default)]
+    pub api_version: EtherscanApiVersion,
     /// The chain name or EIP-155 chain ID.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub chain: Option<Chain>,
@@ -276,13 +279,13 @@ impl ResolvedEtherscanConfig {
     pub fn create(
         api_key: impl Into<String>,
         chain: impl Into<Chain>,
-        api_version: Option<impl Into<String>>,
+        api_version: EtherscanApiVersion,
     ) -> Option<Self> {
         let chain = chain.into();
         let (api_url, browser_url) = chain.etherscan_urls()?;
         Some(Self {
             api_url: api_url.to_string(),
-            api_version: api_version.map(|v| v.into()),
+            api_version,
             browser_url: Some(browser_url.to_string()),
             key: api_key.into(),
             chain: Some(chain),
@@ -330,14 +333,13 @@ impl ResolvedEtherscanConfig {
         }
 
         let api_url = into_url(&api_url)?;
-        let parsed_api_version = api_version.map(EtherscanApiVersion::try_from).transpose()?;
         let client = reqwest::Client::builder()
             .user_agent(ETHERSCAN_USER_AGENT)
             .tls_built_in_root_certs(api_url.scheme() == "https")
             .build()?;
         foundry_block_explorers::Client::builder()
             .with_client(client)
-            .with_api_version(parsed_api_version.unwrap_or_default())
+            .with_api_version(api_version)
             .with_api_key(api_key)
             .with_api_url(api_url)?
             // the browser url is not used/required by the client so we can simply set the
@@ -452,7 +454,7 @@ mod tests {
         let mut resolved = configs.resolved();
         let config = resolved.remove("mainnet").unwrap().unwrap();
         // None version = None
-        assert_eq!(config.api_version, None);
+        assert_eq!(config.api_version, EtherscanApiVersion::V2);
         let client = config.into_client().unwrap();
         assert_eq!(*client.etherscan_api_version(), EtherscanApiVersion::V2);
     }
@@ -472,7 +474,7 @@ mod tests {
 
         let mut resolved = configs.resolved();
         let config = resolved.remove("mainnet").unwrap().unwrap();
-        assert_eq!(config.api_version, Some("v1".to_string()));
+        assert_eq!(config.api_version, EtherscanApiVersion::V1);
         let client = config.into_client().unwrap();
         assert_eq!(*client.etherscan_api_version(), EtherscanApiVersion::V1);
     }

crates/config/src/lib.rs

@@ -96,6 +96,7 @@ pub mod fix;
 // reexport so cli types can implement `figment::Provider` to easily merge compiler arguments
 pub use alloy_chains::{Chain, NamedChain};
 pub use figment;
+use foundry_block_explorers::EtherscanApiVersion;
 
 pub mod providers;
 pub use providers::Remappings;
@@ -120,6 +121,7 @@ mod bind_json;
 use bind_json::BindJsonConfig;
 
 mod compilation;
+use crate::etherscan::EtherscanConfigError::InvalidApiVersion;
 pub use compilation::{CompilationRestrictions, SettingsOverrides};
 
 /// Foundry configuration
@@ -281,6 +283,8 @@ pub struct Config {
     pub eth_rpc_headers: Option<Vec<String>>,
     /// etherscan API key, or alias for an `EtherscanConfig` in `etherscan` table
     pub etherscan_api_key: Option<String>,
+    /// etherscan API version
+    pub etherscan_api_version: Option<String>,
     /// Multiple etherscan api configs and their aliases
     #[serde(default, skip_serializing_if = "EtherscanConfigs::is_empty")]
     pub etherscan: EtherscanConfigs,
@@ -1406,7 +1410,14 @@ impl Config {
         // etherscan fallback via API key
         if let Some(key) = self.etherscan_api_key.as_ref() {
             let chain = chain.or(self.chain).unwrap_or_default();
-            return Ok(ResolvedEtherscanConfig::create(key, chain, None::<String>));
+
+            let api_version = match self.etherscan_api_version.as_ref() {
+                Some(api_version) => EtherscanApiVersion::try_from(api_version.to_string())
+                    .map_err(|_| InvalidApiVersion(api_version.to_string()))?,
+                None => EtherscanApiVersion::V2,
+            };
+
+            return Ok(ResolvedEtherscanConfig::create(key, chain, api_version));
         }
 
         Ok(None)
@@ -2369,6 +2380,7 @@ impl Default for Config {
             eth_rpc_timeout: None,
             eth_rpc_headers: None,
             etherscan_api_key: None,
+            etherscan_api_version: None,
             verbosity: 0,
             remappings: vec![],
             auto_detect_remappings: true,
@@ -3081,7 +3093,7 @@ mod tests {
                             api_url: mainnet_urls.0.to_string(),
                             chain: Some(NamedChain::Mainnet.into()),
                             browser_url: Some(mainnet_urls.1.to_string()),
-                            api_version: None,
+                            api_version: EtherscanApiVersion::V2,
                             key: "FX42Z3BBJJEWXWGYV2X1CIPRSCN".to_string(),
                         }
                     ),
@@ -3091,7 +3103,7 @@ mod tests {
                             api_url: mb_urls.0.to_string(),
                             chain: Some(Moonbeam.into()),
                             browser_url: Some(mb_urls.1.to_string()),
-                            api_version: None,
+                            api_version: EtherscanApiVersion::V2,
                             key: "123456789".to_string(),
                         }
                     ),
@@ -3136,7 +3148,7 @@ mod tests {
                             api_url: mainnet_urls.0.to_string(),
                             chain: Some(NamedChain::Mainnet.into()),
                             browser_url: Some(mainnet_urls.1.to_string()),
-                            api_version: Some("v2".to_string()),
+                            api_version: EtherscanApiVersion::V2,
                             key: "FX42Z3BBJJEWXWGYV2X1CIPRSCN".to_string(),
                         }
                     ),
@@ -3146,7 +3158,7 @@ mod tests {
                             api_url: mb_urls.0.to_string(),
                             chain: Some(Moonbeam.into()),
                             browser_url: Some(mb_urls.1.to_string()),
-                            api_version: Some("v1".to_string()),
+                            api_version: EtherscanApiVersion::V1,
                             key: "123456789".to_string(),
                         }
                     ),

crates/forge/src/cmd/create.rs

@@ -228,6 +228,7 @@ impl CreateArgs {
             num_of_optimizations: None,
             etherscan: EtherscanOpts {
                 key: self.eth.etherscan.key.clone(),
+                api_version: self.eth.etherscan.api_version.clone(),
                 chain: Some(chain.into()),
             },
             rpc: Default::default(),
@@ -416,7 +417,11 @@ impl CreateArgs {
             constructor_args,
             constructor_args_path: None,
             num_of_optimizations,
-            etherscan: EtherscanOpts { key: self.eth.etherscan.key(), chain: Some(chain.into()) },
+            etherscan: EtherscanOpts {
+                key: self.eth.etherscan.key(),
+                api_version: self.eth.etherscan.api_version.clone(),
+                chain: Some(chain.into()),
+            },
             rpc: Default::default(),
             flatten: false,
             force: false,

crates/forge/tests/cli/config.rs

@@ -119,6 +119,7 @@ forgetest!(can_extract_config_values, |prj, cmd| {
         eth_rpc_timeout: None,
         eth_rpc_headers: None,
         etherscan_api_key: None,
+        etherscan_api_version: None,
         etherscan: Default::default(),
         verbosity: 4,
         remappings: vec![Remapping::from_str("forge-std/=lib/forge-std/").unwrap().into()],

crates/verify/src/bytecode.rs

@@ -141,6 +141,7 @@ impl VerifyBytecodeArgs {
             &self.verifier.verifier,
             self.verifier.verifier_url.as_deref(),
             self.etherscan.key().as_deref(),
+            self.verifier.verifier_api_version.as_deref(),
             &config,
         )?;
 

crates/verify/src/etherscan/mod.rs

@@ -12,7 +12,7 @@ use foundry_block_explorers::{
     errors::EtherscanError,
     utils::lookup_compiler_version,
     verify::{CodeFormat, VerifyContract},
-    Client,
+    Client, EtherscanApiVersion,
 };
 use foundry_cli::utils::{get_provider, read_constructor_args_file, LoadConfig};
 use foundry_common::{abi::encode_function_args, retry::RetryError};
@@ -155,6 +155,7 @@ impl VerificationProvider for EtherscanVerificationProvider {
             &args.verifier.verifier,
             args.verifier.verifier_url.as_deref(),
             args.etherscan.key().as_deref(),
+            args.verifier.verifier_api_version.as_deref(),
             &config,
         )?;
         args.retry
@@ -224,6 +225,7 @@ impl EtherscanVerificationProvider {
             &args.verifier.verifier,
             args.verifier.verifier_url.as_deref(),
             args.etherscan.key().as_deref(),
+            args.verifier.verifier_api_version.as_deref(),
             &config,
         )?;
         let verify_args = self.create_verify_request(args, context).await?;
@@ -256,13 +258,28 @@ impl EtherscanVerificationProvider {
         verifier_type: &VerificationProviderType,
         verifier_url: Option<&str>,
         etherscan_key: Option<&str>,
+        verifier_api_version: Option<&str>,
         config: &Config,
     ) -> Result<Client> {
         let etherscan_config = config.get_etherscan_config_with_chain(Some(chain))?;
 
+        let api_version = match verifier_api_version {
+            Some(api_version) => EtherscanApiVersion::try_from(api_version.to_string())?,
+            None => {
+                if verifier_type.is_etherscan() {
+                    etherscan_config
+                        .as_ref()
+                        .map(|c| c.api_version)
+                        .unwrap_or(EtherscanApiVersion::V2)
+                } else {
+                    EtherscanApiVersion::V1
+                }
+            }
+        };
+
         let etherscan_api_url = verifier_url
             .or_else(|| {
-                if verifier_type.is_etherscan_v2() {
+                if api_version == EtherscanApiVersion::V2 {
                     None
                 } else {
                     etherscan_config.as_ref().map(|c| c.api_url.as_str())
@@ -277,13 +294,8 @@ impl EtherscanVerificationProvider {
             .or_else(|| chain.etherscan_urls().map(|(_, url)| url));
         let etherscan_key =
             etherscan_key.or_else(|| etherscan_config.as_ref().map(|c| c.key.as_str()));
-        let etherscan_api_version = if verifier_type.is_etherscan_v2() {
-            foundry_block_explorers::EtherscanApiVersion::V2
-        } else {
-            foundry_block_explorers::EtherscanApiVersion::V1
-        };
 
-        let mut builder = Client::builder().with_api_version(etherscan_api_version);
+        let mut builder = Client::builder().with_api_version(api_version);
 
         builder = if let Some(api_url) = api_url {
             // we don't want any trailing slashes because this can cause cloudflare issues: <https://github.com/foundry-rs/foundry/pull/6079>
@@ -407,6 +419,7 @@ impl EtherscanVerificationProvider {
             &args.verifier.verifier,
             args.verifier.verifier_url.as_deref(),
             args.etherscan.key.as_deref(),
+            args.verifier.verifier_api_version.as_deref(),
             &context.config,
         )?;
 
@@ -476,7 +489,6 @@ async fn ensure_solc_build_metadata(version: Version) -> Result<Version> {
 mod tests {
     use super::*;
     use clap::Parser;
-    use foundry_block_explorers::EtherscanApiVersion;
     use foundry_common::fs;
     use foundry_test_utils::{forgetest_async, str};
     use tempfile::tempdir;
@@ -515,6 +527,7 @@ mod tests {
                 &args.verifier.verifier,
                 args.verifier.verifier_url.as_deref(),
                 args.etherscan.key().as_deref(),
+                args.verifier.verifier_api_version.as_deref(),
                 &config,
             )
             .unwrap();
@@ -543,6 +556,7 @@ mod tests {
                 &args.verifier.verifier,
                 args.verifier.verifier_url.as_deref(),
                 args.etherscan.key().as_deref(),
+                args.verifier.verifier_api_version.as_deref(),
                 &config,
             )
             .unwrap();
@@ -570,7 +584,7 @@ mod tests {
             "0xd8509bee9c9bf012282ad33aba0d87241baf5064",
             "src/Counter.sol:Counter",
             "--verifier",
-            "etherscan-v2",
+            "etherscan",
             "--chain",
             "mumbai",
             "--root",
@@ -587,6 +601,7 @@ mod tests {
                 &args.verifier.verifier,
                 args.verifier.verifier_url.as_deref(),
                 args.etherscan.key().as_deref(),
+                args.verifier.verifier_api_version.as_deref(),
                 &config,
             )
             .unwrap();
@@ -599,7 +614,7 @@ mod tests {
             "0xd8509bee9c9bf012282ad33aba0d87241baf5064",
             "src/Counter.sol:Counter",
             "--verifier",
-            "etherscan-v2",
+            "etherscan",
             "--chain",
             "mumbai",
             "--verifier-url",
@@ -610,7 +625,7 @@ mod tests {
 
         let config = args.load_config().unwrap();
 
-        assert_eq!(args.verifier.verifier, VerificationProviderType::EtherscanV2);
+        assert_eq!(args.verifier.verifier, VerificationProviderType::Etherscan);
 
         let etherscan = EtherscanVerificationProvider::default();
         let client = etherscan
@@ -619,6 +634,7 @@ mod tests {
                 &args.verifier.verifier,
                 args.verifier.verifier_url.as_deref(),
                 args.etherscan.key().as_deref(),
+                args.verifier.verifier_api_version.as_deref(),
                 &config,
             )
             .unwrap();