chore: deprecate Etherscan V1 (#101)

Should be considered as part of
foundry-rs/foundry#10913 and merged after
initial approval of main PR:
foundry-rs/foundry#11387

Author: zerosnacks

crates/block-explorers/src/lib.rs

@@ -24,10 +24,8 @@ use reqwest::{header, IntoUrl, Url};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{
     borrow::Cow,
-    collections::HashMap,
     io::Write,
     path::PathBuf,
-    str::FromStr,
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
@@ -46,65 +44,19 @@ pub mod verify;
 
 pub(crate) type Result<T, E = EtherscanError> = std::result::Result<T, E>;
 
-/// The URL for the etherscan V2 API without the chainid param set.
-pub const ETHERSCAN_V2_API_BASE_URL: &str = "https://api.etherscan.io/v2/api";
-
-/// The Etherscan.io API version 1 - classic verifier, one API per chain, 2 - new multichain
-/// verifier
-#[derive(Clone, Default, Debug, PartialEq, Copy, Eq, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum EtherscanApiVersion {
-    V1,
-    #[default]
-    V2,
-}
-
-impl std::fmt::Display for EtherscanApiVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            EtherscanApiVersion::V1 => write!(f, "v1"),
-            EtherscanApiVersion::V2 => write!(f, "v2"),
-        }
-    }
-}
-
-impl TryFrom<String> for EtherscanApiVersion {
-    type Error = EtherscanError;
-
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        Self::from_str(value.as_str())
-    }
-}
-
-impl FromStr for EtherscanApiVersion {
-    type Err = EtherscanError;
-
-    fn from_str(value: &str) -> Result<Self, Self::Err> {
-        match value {
-            "v1" | "V1" => Ok(EtherscanApiVersion::V1),
-            "v2" | "V2" => Ok(EtherscanApiVersion::V2),
-            _ => Err(EtherscanError::InvalidApiVersion),
-        }
-    }
-}
-
 /// The Etherscan.io API client.
 #[derive(Clone, Debug)]
 pub struct Client {
     /// Client that executes HTTP requests
     client: reqwest::Client,
     /// Etherscan API key
     api_key: Option<String>,
-    /// Etherscan API version
-    etherscan_api_version: EtherscanApiVersion,
     /// Etherscan API endpoint like <https://api.etherscan.io/v2/api?chainid=(chain_id)>
     etherscan_api_url: Url,
     /// Etherscan base endpoint like <https://etherscan.io>
     etherscan_url: Url,
     /// Path to where ABI files should be cached
     cache: Option<Cache>,
-    /// Chain ID
-    chain_id: Option<u64>,
 }
 
 impl Client {
@@ -145,32 +97,9 @@ impl Client {
         Client::builder().with_api_key(api_key).chain(chain)?.build()
     }
 
-    /// Create a new client for the given [`EtherscanApiVersion`].
-    pub fn new_with_api_version(
-        chain: Chain,
-        api_key: impl Into<String>,
-        api_version: EtherscanApiVersion,
-    ) -> Result<Self> {
-        Client::builder().with_api_key(api_key).with_api_version(api_version).chain(chain)?.build()
-    }
-
     /// Create a new client with the correct endpoint with the chain
     pub fn new_from_env(chain: Chain) -> Result<Self> {
-        Self::new_with_api_version(
-            chain,
-            get_api_key_from_chain(chain, EtherscanApiVersion::V2)?,
-            EtherscanApiVersion::V2,
-        )
-    }
-
-    /// Create a new client with the correct endpoints based on the chain and API key
-    /// from the default environment variable defined in [`Chain`].
-    pub fn new_v1_from_env(chain: Chain) -> Result<Self> {
-        Self::new_with_api_version(
-            chain,
-            get_api_key_from_chain(chain, EtherscanApiVersion::V1)?,
-            EtherscanApiVersion::V1,
-        )
+        Client::builder().with_api_key(get_api_key_from_chain(chain)?).chain(chain)?.build()
     }
 
     /// Create a new client with the correct endpoints based on the chain and API key
@@ -193,11 +122,6 @@ impl Client {
         self
     }
 
-    /// Returns the configured etherscan api version.
-    pub fn etherscan_api_version(&self) -> &EtherscanApiVersion {
-        &self.etherscan_api_version
-    }
-
     pub fn etherscan_api_url(&self) -> &Url {
         &self.etherscan_api_url
     }
@@ -262,20 +186,10 @@ impl Client {
     async fn post<F: Serialize>(&self, form: &F) -> Result<String> {
         trace!(target: "etherscan", "POST {}", self.etherscan_api_url);
 
-        let mut post_query = HashMap::new();
-
-        if self.etherscan_api_version == EtherscanApiVersion::V2
-            && self.chain_id.is_some()
-            && !self.url_contains_chainid()
-        {
-            post_query.insert("chainid", self.chain_id.unwrap());
-        }
-
         let response = self
             .client
             .post(self.etherscan_api_url.clone())
             .form(form)
-            .query(&post_query)
             .send()
             .await?
             .text()
@@ -325,14 +239,9 @@ impl Client {
             apikey: self.api_key.as_deref().map(Cow::Borrowed),
             module: Cow::Borrowed(module),
             action: Cow::Borrowed(action),
-            chain_id: if self.url_contains_chainid() { None } else { self.chain_id },
             other,
         }
     }
-
-    fn url_contains_chainid(&self) -> bool {
-        self.etherscan_api_url.query_pairs().any(|(key, _)| key.eq_ignore_ascii_case("chainid"))
-    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -343,57 +252,39 @@ pub struct ClientBuilder {
     api_key: Option<String>,
     /// Etherscan API endpoint like <https://api.etherscan.io/v2/api?chainid=(chain_id)>
     etherscan_api_url: Option<Url>,
-    /// Etherscan API version (v2 is new verifier version, v1 is the default)
-    etherscan_api_version: EtherscanApiVersion,
     /// Etherscan base endpoint like <https://etherscan.io>
     etherscan_url: Option<Url>,
     /// Path to where ABI files should be cached
     cache: Option<Cache>,
-    /// Chain ID
-    chain_id: Option<u64>,
 }
 
 // === impl ClientBuilder ===
 
 impl ClientBuilder {
-    /// Configures the etherscan url and api url for the given chain
+    /// Configures the Etherscan url and api url for the given chain
     ///
-    /// Note: This method also sets the chain_id for etherscan multichain verification: <https://docs.etherscan.io/contract-verification/multichain-verification>
+    /// Note: This method also sets the chain_id for Etherscan multichain verification: <https://docs.etherscan.io/contract-verification/multichain-verification>
     ///
     /// # Errors
     ///
-    /// Fails if the chain is not supported by etherscan
+    /// Fails if the chain is not supported by Etherscan
     pub fn chain(self, chain: Chain) -> Result<Self> {
         fn urls(
             (api, url): (impl IntoUrl, impl IntoUrl),
         ) -> (reqwest::Result<Url>, reqwest::Result<Url>) {
             (api.into_url(), url.into_url())
         }
-        let (default_etherscan_api_url, etherscan_url) = chain
+        let (etherscan_api_url, etherscan_url) = chain
             .named()
             .ok_or_else(|| EtherscanError::ChainNotSupported(chain))?
             .etherscan_urls()
             .map(urls)
             .ok_or_else(|| EtherscanError::ChainNotSupported(chain))?;
 
-        // V2 etherscan default API urls are different – this handles that case.
-        let etherscan_api_url = if self.etherscan_api_version == EtherscanApiVersion::V2 {
-            Url::parse(ETHERSCAN_V2_API_BASE_URL)
-                .map_err(|_| EtherscanError::Builder("Bad URL Parse".into()))?
-        } else {
-            default_etherscan_api_url?
-        };
-
-        self.with_chain_id(chain).with_api_url(etherscan_api_url)?.with_url(etherscan_url?)
-    }
-
-    /// Configures the etherscan api version
-    pub fn with_api_version(mut self, api_version: EtherscanApiVersion) -> Self {
-        self.etherscan_api_version = api_version;
-        self
+        self.with_api_url(etherscan_api_url?)?.with_url(etherscan_url?)
     }
 
-    /// Configures the etherscan url
+    /// Configures the Etherscan url
     ///
     /// # Errors
     ///
@@ -409,7 +300,7 @@ impl ClientBuilder {
         self
     }
 
-    /// Configures the etherscan api url
+    /// Configures the Etherscan api url
     ///
     /// # Errors
     ///
@@ -419,29 +310,18 @@ impl ClientBuilder {
         Ok(self)
     }
 
-    /// Configures the etherscan api key
+    /// Configures the Etherscan api key
     pub fn with_api_key(mut self, api_key: impl Into<String>) -> Self {
         self.api_key = Some(api_key.into()).filter(|s| !s.is_empty());
         self
     }
 
-    /// Configures cache for etherscan request
+    /// Configures cache for Etherscan request
     pub fn with_cache(mut self, cache_root: Option<PathBuf>, cache_ttl: Duration) -> Self {
         self.cache = cache_root.map(|root| Cache::new(root, cache_ttl));
         self
     }
 
-    /// Configures the chain id for etherscan verification: <https://docs.etherscan.io/contract-verification/multichain-verification>
-    pub fn with_chain_id(mut self, chain: Chain) -> Self {
-        self.chain_id = Some(chain.id());
-        self
-    }
-
-    /// Returns the chain the client is built on.
-    pub fn get_chain(&self) -> Option<Chain> {
-        self.chain_id.map(Chain::from_id)
-    }
-
     /// Returns a Client that uses this ClientBuilder configuration.
     ///
     /// # Errors
@@ -450,28 +330,17 @@ impl ClientBuilder {
     ///   - `etherscan_api_url`
     ///   - `etherscan_url`
     pub fn build(self) -> Result<Client> {
-        let ClientBuilder {
-            client,
-            api_key,
-            etherscan_api_version,
-            etherscan_api_url,
-            etherscan_url,
-            cache,
-            chain_id,
-        } = self;
+        let ClientBuilder { client, api_key, etherscan_api_url, etherscan_url, cache } = self;
 
         let client = Client {
             client: client.unwrap_or_default(),
             api_key,
             etherscan_api_url: etherscan_api_url
                 .clone()
                 .ok_or_else(|| EtherscanError::Builder("etherscan api url".to_string()))?,
-            // Set default API version to V1 if missing
-            etherscan_api_version,
             etherscan_url: etherscan_url
                 .ok_or_else(|| EtherscanError::Builder("etherscan url".to_string()))?,
             cache,
-            chain_id,
         };
         Ok(client)
     }
@@ -599,8 +468,6 @@ struct Query<'a, T: Serialize> {
     apikey: Option<Cow<'a, str>>,
     module: Cow<'a, str>,
     action: Cow<'a, str>,
-    #[serde(rename = "chainId", skip_serializing_if = "Option::is_none")]
-    chain_id: Option<u64>,
     #[serde(flatten)]
     other: T,
 }
@@ -612,10 +479,7 @@ fn into_url(url: impl IntoUrl) -> std::result::Result<Url, reqwest::Error> {
     url.into_url()
 }
 
-fn get_api_key_from_chain(
-    chain: Chain,
-    api_version: EtherscanApiVersion,
-) -> Result<String, EtherscanError> {
+fn get_api_key_from_chain(chain: Chain) -> Result<String, EtherscanError> {
     match chain.kind() {
         ChainKind::Named(named) => match named {
             // Fantom is special and doesn't support etherscan api v2
@@ -641,24 +505,15 @@ fn get_api_key_from_chain(
 
             // Rather than get special ENV vars here, normal case is to pull overall
             // ETHERSCAN_API_KEY
-            _ => {
-                if api_version == EtherscanApiVersion::V1 {
-                    named
-                        .etherscan_api_key_name()
-                        .ok_or_else(|| EtherscanError::ChainNotSupported(chain))
-                        .and_then(|key_name| std::env::var(key_name).map_err(Into::into))
-                } else {
-                    std::env::var("ETHERSCAN_API_KEY").map_err(Into::into)
-                }
-            }
+            _ => std::env::var("ETHERSCAN_API_KEY").map_err(Into::into),
         },
         ChainKind::Id(_) => Err(EtherscanError::ChainNotSupported(chain)),
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{Client, EtherscanApiVersion, EtherscanError, ResponseData};
+    use crate::{Client, EtherscanError, ResponseData};
     use alloy_chains::Chain;
     use alloy_primitives::{Address, B256};
 
@@ -671,21 +526,13 @@ mod tests {
     }
 
     #[test]
-    fn test_api_paths_v1() {
-        let client =
-            Client::new_with_api_version(Chain::goerli(), "", EtherscanApiVersion::V1).unwrap();
-        assert_eq!(client.etherscan_api_url.as_str(), "https://api-goerli.etherscan.io/api");
-
-        assert_eq!(client.block_url(100), "https://goerli.etherscan.io/block/100");
-    }
-
-    #[test]
-    fn test_api_paths_v2() {
-        let client =
-            Client::new_with_api_version(Chain::goerli(), "", EtherscanApiVersion::V2).unwrap();
-        assert_eq!(client.etherscan_api_url.as_str(), "https://api.etherscan.io/v2/api");
-
-        assert_eq!(client.block_url(100), "https://goerli.etherscan.io/block/100");
+    fn test_api_paths() {
+        let client = Client::new(Chain::sepolia(), "").unwrap();
+        assert_eq!(
+            client.etherscan_api_url.as_str(),
+            "https://api.etherscan.io/v2/api?chainid=11155111"
+        );
+        assert_eq!(client.block_url(100), "https://sepolia.etherscan.io/block/100");
     }
 
     #[test]
@@ -736,19 +583,4 @@ mod tests {
         let resp: ResponseData<Address> = serde_json::from_value(err).unwrap();
         assert!(matches!(resp, ResponseData::Error { .. }));
     }
-
-    #[test]
-    fn can_parse_api_version() {
-        assert_eq!(
-            EtherscanApiVersion::try_from("v1".to_string()).unwrap(),
-            EtherscanApiVersion::V1
-        );
-        assert_eq!(
-            EtherscanApiVersion::try_from("v2".to_string()).unwrap(),
-            EtherscanApiVersion::V2
-        );
-
-        let parse_err = EtherscanApiVersion::try_from("fail".to_string()).unwrap_err();
-        assert!(matches!(parse_err, EtherscanError::InvalidApiVersion));
-    }
 }