fix(forge): custom verifiers should not throw on unknown etherscan chains (#11442)

* fix(forge): check if supported chain in verifier client

* Apply suggestions from code review

* heck if verifier url passed if not etherscan

* Tests

---------

Co-authored-by: zerosnacks <95942363+zerosnacks@users.noreply.github.com>

Author: grandizzy

crates/config/src/lib.rs

@@ -62,9 +62,8 @@ pub use endpoints::{
 };
 
 mod etherscan;
-use etherscan::{
-    EtherscanConfigError, EtherscanConfigs, EtherscanEnvProvider, ResolvedEtherscanConfig,
-};
+pub use etherscan::EtherscanConfigError;
+use etherscan::{EtherscanConfigs, EtherscanEnvProvider, ResolvedEtherscanConfig};
 
 pub mod resolve;
 pub use resolve::UnresolvedEnvVarError;
@@ -1443,15 +1442,10 @@ impl Config {
 
         // etherscan fallback via API key
         if let Some(key) = self.etherscan_api_key.as_ref() {
-            match ResolvedEtherscanConfig::create(key, chain.or(self.chain).unwrap_or_default()) {
-                Some(config) => return Ok(Some(config)),
-                None => {
-                    return Err(EtherscanConfigError::UnknownChain(
-                        String::new(),
-                        chain.unwrap_or_default(),
-                    ));
-                }
-            }
+            return Ok(ResolvedEtherscanConfig::create(
+                key,
+                chain.or(self.chain).unwrap_or_default(),
+            ));
         }
         Ok(None)
     }

crates/forge/tests/cli/verify.rs

@@ -314,3 +314,49 @@ forgetest!(can_guess_constructor_args, |prj, cmd| {
 forgetest!(can_verify_random_contract_sepolia_default_sourcify, |prj, cmd| {
     verify_on_chain(EnvExternalities::sepolia_empty_verifier(), prj, cmd);
 });
+
+// Tests that verify properly validates verifier arguments.
+// <https://github.com/foundry-rs/foundry/issues/11430>
+forgetest_init!(can_validate_verifier_settings, |prj, cmd| {
+    // No verifier URL.
+    cmd.args([
+        "verify-contract",
+        "--rpc-url",
+        "https://rpc.sepolia-api.lisk.com",
+        "--verifier",
+        "blockscout",
+        "0x19b248616E4964f43F611b5871CE1250f360E9d3",
+        "src/Counter.sol:Counter",
+    ])
+    .assert_failure()
+    .stderr_eq(str![[r#"
+Error: No verifier URL specified for verifier blockscout
+
+"#]]);
+
+    // Unknown Etherscan chain.
+    cmd.forge_fuse()
+        .args([
+            "verify-contract",
+            "--rpc-url",
+            "https://rpc.sepolia-api.lisk.com",
+            "--verifier",
+            "etherscan",
+            "0x19b248616E4964f43F611b5871CE1250f360E9d3",
+            "src/Counter.sol:Counter",
+        ])
+        .assert_failure()
+        .stderr_eq(str![[r#"
+Error: No known Etherscan API URL for chain `4202`. To fix this, please:
+1. Specify a `url` 
+2. Verify the chain `4202` is correct
+
+"#]]);
+
+    cmd.forge_fuse().args(["verify-contract", "--rpc-url", "https://rpc.sepolia-api.lisk.com", "--verifier", "blockscout", "--verifier-url", "https://sepolia-blockscout.lisk.com/api", "0x19b248616E4964f43F611b5871CE1250f360E9d3", "src/Counter.sol:Counter"]).assert_success().stdout_eq(str![[r#"
+Start verifying contract `0x19b248616E4964f43F611b5871CE1250f360E9d3` deployed on 4202
+
+Contract [src/Counter.sol:Counter] "0x19b248616E4964f43F611b5871CE1250f360E9d3" is already verified. Skipping verification.
+
+"#]]);
+});

crates/verify/src/provider.rs

@@ -14,7 +14,7 @@ use foundry_compilers::{
     multi::{MultiCompilerParser, MultiCompilerSettings},
     solc::Solc,
 };
-use foundry_config::Config;
+use foundry_config::{Chain, Config, EtherscanConfigError};
 use semver::Version;
 use std::{fmt, path::PathBuf, str::FromStr};
 
@@ -168,7 +168,12 @@ pub enum VerificationProviderType {
 
 impl VerificationProviderType {
     /// Returns the corresponding `VerificationProvider` for the key
-    pub fn client(&self, key: Option<&str>) -> Result<Box<dyn VerificationProvider>> {
+    pub fn client(
+        &self,
+        key: Option<&str>,
+        chain: Option<Chain>,
+        has_url: bool,
+    ) -> Result<Box<dyn VerificationProvider>> {
         let has_key = key.as_ref().is_some_and(|k| !k.is_empty());
         // 1. If no verifier or `--verifier sourcify` is set and no API key provided, use Sourcify.
         if !has_key && self.is_sourcify() {
@@ -179,17 +184,26 @@ impl VerificationProviderType {
             return Ok(Box::<SourcifyVerificationProvider>::default());
         }
 
-        // 2. If `--verifier etherscan` is explicitly set, enforce the API key requirement.
+        // 2. If `--verifier etherscan` is explicitly set, check if chain is supported and
+        // enforce the API key requirement.
         if self.is_etherscan() {
+            if let Some(chain) = chain
+                && chain.etherscan_urls().is_none()
+            {
+                eyre::bail!(EtherscanConfigError::UnknownChain(String::new(), chain))
+            }
             if !has_key {
                 eyre::bail!("ETHERSCAN_API_KEY must be set to use Etherscan as a verifier")
             }
             return Ok(Box::<EtherscanVerificationProvider>::default());
         }
 
         // 3. If `--verifier blockscout | oklink | custom` is explicitly set, use the chosen
-        //    verifier.
+        //    verifier and make sure an URL was specified.
         if matches!(self, Self::Blockscout | Self::Oklink | Self::Custom) {
+            if !has_url {
+                eyre::bail!("No verifier URL specified for verifier {}", self);
+            }
             return Ok(Box::<EtherscanVerificationProvider>::default());
         }
 

crates/verify/src/verify.rs

@@ -253,7 +253,7 @@ impl VerifyArgs {
         {
             sh_println!("Constructor args: {args}")?
         }
-        self.verifier.verifier.client(self.etherscan.key().as_deref())?.verify(self, context).await.map_err(|err| {
+        self.verifier.verifier.client(self.etherscan.key().as_deref(), self.etherscan.chain, self.verifier.verifier_url.is_some())?.verify(self, context).await.map_err(|err| {
             if let Some(verifier_url) = verifier_url {
                  match Url::parse(&verifier_url) {
                     Ok(url) => {
@@ -277,7 +277,11 @@ impl VerifyArgs {
 
     /// Returns the configured verification provider
     pub fn verification_provider(&self) -> Result<Box<dyn VerificationProvider>> {
-        self.verifier.verifier.client(self.etherscan.key().as_deref())
+        self.verifier.verifier.client(
+            self.etherscan.key().as_deref(),
+            self.etherscan.chain,
+            self.verifier.verifier_url.is_some(),
+        )
     }
 
     /// Resolves [VerificationContext] object either from entered contract name or by trying to
@@ -476,7 +480,15 @@ impl VerifyCheckArgs {
             "Checking verification status on {}",
             self.etherscan.chain.unwrap_or_default()
         )?;
-        self.verifier.verifier.client(self.etherscan.key().as_deref())?.check(self).await
+        self.verifier
+            .verifier
+            .client(
+                self.etherscan.key().as_deref(),
+                self.etherscan.chain,
+                self.verifier.verifier_url.is_some(),
+            )?
+            .check(self)
+            .await
     }
 }