feat: add ZkVerificationProvider and allows for verification via zksy…

…nc block explorer

crates/forge/bin/cmd/create.rs

@@ -354,9 +354,9 @@ impl CreateArgs {
             config.get_etherscan_config_with_chain(Some(chain.into()))?.map(|c| c.key);
 
         let context = if verify.zksync {
-            CompilerVerificationContext::Solc(verify.resolve_context().await?)
-        } else {
             CompilerVerificationContext::ZkSolc(verify.zk_resolve_context().await?)
+        } else {
+            CompilerVerificationContext::Solc(verify.resolve_context().await?)
         };
 
         verify.verification_provider()?.preflight_check(verify, context).await?;

crates/verify/src/lib.rs

@@ -36,6 +36,7 @@ use provider::VerificationProvider;
 pub mod bytecode;
 pub mod retry;
 mod sourcify;
+mod zksync;
 
 pub use retry::RetryArgs;
 

crates/verify/src/provider.rs

@@ -1,6 +1,6 @@
 use super::{
-    etherscan::EtherscanVerificationProvider, sourcify::SourcifyVerificationProvider, VerifyArgs,
-    VerifyCheckArgs,
+    etherscan::EtherscanVerificationProvider, sourcify::SourcifyVerificationProvider,
+    zksync::ZkVerificationProvider, VerifyArgs, VerifyCheckArgs,
 };
 use crate::zk_provider::CompilerVerificationContext;
 use alloy_json_abi::JsonAbi;
@@ -128,6 +128,7 @@ impl FromStr for VerificationProviderType {
             "s" | "sourcify" => Ok(Self::Sourcify),
             "b" | "blockscout" => Ok(Self::Blockscout),
             "o" | "oklink" => Ok(Self::Oklink),
+            "z" | "zksync" => Ok(Self::ZKsync),
             _ => Err(format!("Unknown provider: {s}")),
         }
     }
@@ -148,6 +149,9 @@ impl fmt::Display for VerificationProviderType {
             Self::Oklink => {
                 write!(f, "oklink")?;
             }
+            Self::ZKsync => {
+                write!(f, "zksync")?;
+            }
         };
         Ok(())
     }
@@ -160,6 +164,8 @@ pub enum VerificationProviderType {
     Sourcify,
     Blockscout,
     Oklink,
+    #[value(alias = "zksync")]
+    ZKsync,
 }
 
 impl VerificationProviderType {
@@ -175,6 +181,7 @@ impl VerificationProviderType {
             Self::Sourcify => Ok(Box::<SourcifyVerificationProvider>::default()),
             Self::Blockscout => Ok(Box::<EtherscanVerificationProvider>::default()),
             Self::Oklink => Ok(Box::<EtherscanVerificationProvider>::default()),
+            Self::ZKsync => Ok(Box::<ZkVerificationProvider>::default()),
         }
     }
 }

crates/verify/src/zk_provider.rs

@@ -1,8 +1,6 @@
 use crate::provider::VerificationContext;
 
-use super::{VerifyArgs, VerifyCheckArgs};
 use alloy_json_abi::JsonAbi;
-use async_trait::async_trait;
 use eyre::{OptionExt, Result};
 use foundry_common::compile::ProjectCompiler;
 use foundry_compilers::{
@@ -124,29 +122,6 @@ impl ZkVerificationContext {
     }
 }
 
-/// An abstraction for various verification providers such as etherscan, sourcify, blockscout
-#[async_trait]
-pub trait ZkVerificationProvider {
-    /// This should ensure the verify request can be prepared successfully.
-    ///
-    /// Caution: Implementers must ensure that this _never_ sends the actual verify request
-    /// `[VerificationProvider::verify]`, instead this is supposed to evaluate whether the given
-    /// [`VerifyArgs`] are valid to begin with. This should prevent situations where there's a
-    /// contract deployment that's executed before the verify request and the subsequent verify task
-    /// fails due to misconfiguration.
-    async fn preflight_check(
-        &mut self,
-        args: VerifyArgs,
-        context: ZkVerificationContext,
-    ) -> Result<()>;
-
-    /// Sends the actual verify request for the targeted contract.
-    async fn verify(&mut self, args: VerifyArgs, context: ZkVerificationContext) -> Result<()>;
-
-    /// Checks whether the contract is verified.
-    async fn check(&self, args: VerifyCheckArgs) -> Result<()>;
-}
-
 #[derive(Debug)]
 pub enum CompilerVerificationContext {
     Solc(VerificationContext),