Add unified backend trait and polymorphic command dispatch

The changes introduce a new Backend trait that provides a common
interface for Cairo and EVM proof system implementations, along with a
factory pattern for creating backend instances. Command dispatching is
updated to use this new abstraction.

Author: 0xpantera

crates/bargo-core/src/backend.rs

@@ -0,0 +1,71 @@
+//! Backend trait and factory for polymorphic proof system backends
+//!
+//! This module provides a unified interface for different proof system backends
+//! (Cairo/Starknet and EVM/Ethereum), allowing them to be used interchangeably
+//! through trait objects or concrete types.
+
+use color_eyre::Result;
+
+use crate::config::Config;
+
+/// Trait for polymorphic backend implementations (Cairo, EVM, etc.)
+///
+/// This trait provides a unified interface for different proof system backends,
+/// allowing them to be used interchangeably through dynamic dispatch.
+pub trait Backend {
+    /// Generate verifier contract and setup project structure
+    fn generate(&self, cfg: &Config) -> Result<()>;
+
+    /// Generate proof using the backend's proof system
+    fn prove(&self, cfg: &Config) -> Result<()>;
+
+    /// Verify a generated proof
+    fn verify(&self, cfg: &Config) -> Result<()>;
+
+    /// Generate calldata for proof verification
+    fn calldata(&self, cfg: &Config) -> Result<()>;
+
+    /// Deploy verifier contract to specified network
+    ///
+    /// Note: Implementation varies by backend:
+    /// - Cairo: Two-step process (declare contract to get class_hash, then deploy instance)
+    /// - EVM: Single-step process (deploy contract directly to network)
+    fn deploy(&self, cfg: &Config, network: Option<&str>) -> Result<()>;
+
+    /// Verify proof on-chain using deployed verifier
+    fn verify_onchain(&self, cfg: &Config, address: Option<&str>) -> Result<()>;
+}
+
+/// Backend type identifier for factory function
+#[derive(Debug, Clone, Copy)]
+pub enum BackendKind {
+    /// Cairo/Starknet backend
+    Cairo,
+    /// EVM/Ethereum backend
+    Evm,
+}
+
+/// Factory function to create appropriate backend implementation
+///
+/// This function creates concrete backend implementations based on the backend kind,
+/// returning a boxed trait object that can be used polymorphically.
+///
+/// # Arguments
+/// * `backend_kind` - The backend kind (Cairo or EVM)
+///
+/// # Returns
+/// * `Box<dyn Backend>` - Boxed backend implementation
+///
+/// # Example
+/// ```ignore
+/// let backend = backend_for(BackendKind::Cairo);
+/// backend.generate(&config)?;
+/// ```
+pub fn backend_for(backend_kind: BackendKind) -> Box<dyn Backend> {
+    use crate::commands::{cairo, evm};
+
+    match backend_kind {
+        BackendKind::Cairo => Box::new(cairo::backend::CairoBackend::new()),
+        BackendKind::Evm => Box::new(evm::backend::EvmBackend::new()),
+    }
+}

crates/bargo-core/src/lib.rs

@@ -5,10 +5,13 @@ use tracing::{info, warn};
 mod backends;
 mod util;
 
+pub mod backend;
 pub mod cli;
 pub mod commands;
 pub mod config;
 
+use backend::{BackendKind, backend_for};
+
 pub use cli::Cli;
 pub use config::Config;
 
@@ -70,81 +73,93 @@ fn dispatch(cli: &Cli, cfg: &Config) -> Result<()> {
                 if !cfg.quiet {
                     print_banner("cairo gen");
                 }
-                commands::cairo::run_gen(cfg)
+                let backend = backend_for(BackendKind::Cairo);
+                backend.generate(cfg)
             }
             CairoCommands::Prove => {
                 if !cfg.quiet {
                     print_banner("cairo prove");
                 }
-                commands::cairo::run_prove(cfg)
+                let backend = backend_for(BackendKind::Cairo);
+                backend.prove(cfg)
             }
             CairoCommands::Verify => {
                 if !cfg.quiet {
                     print_banner("cairo verify");
                 }
-                commands::cairo::run_verify(cfg)
+                let backend = backend_for(BackendKind::Cairo);
+                backend.verify(cfg)
             }
             CairoCommands::Calldata => {
                 if !cfg.quiet {
                     print_banner("cairo calldata");
                 }
-                commands::cairo::run_calldata(cfg)
+                let backend = backend_for(BackendKind::Cairo);
+                backend.calldata(cfg)
             }
             CairoCommands::Declare { network } => {
                 if !cfg.quiet {
                     print_banner("cairo declare");
                 }
                 commands::cairo::run_declare(cfg, network)
             }
-            CairoCommands::Deploy { class_hash } => {
+            CairoCommands::Deploy { class_hash: _ } => {
                 if !cfg.quiet {
                     print_banner("cairo deploy");
                 }
-                commands::cairo::run_deploy(cfg, class_hash.as_deref())
+                let backend = backend_for(BackendKind::Cairo);
+                backend.deploy(cfg, None)
             }
             CairoCommands::VerifyOnchain { address } => {
                 if !cfg.quiet {
                     print_banner("cairo verify-onchain");
                 }
-                commands::cairo::run_verify_onchain(cfg, address.as_deref())
+                let backend = backend_for(BackendKind::Cairo);
+                backend.verify_onchain(cfg, address.as_deref())
             }
         },
         Commands::Evm { command } => match command {
             EvmCommands::Gen => {
                 if !cfg.quiet {
                     print_banner("evm gen");
                 }
-                commands::evm::run_gen(cfg)
+                let backend = backend_for(BackendKind::Evm);
+                backend.generate(cfg)
             }
             EvmCommands::Prove => {
                 if !cfg.quiet {
                     print_banner("evm prove");
                 }
-                commands::evm::run_prove(cfg)
+                let backend = backend_for(BackendKind::Evm);
+                backend.prove(cfg)
             }
             EvmCommands::Verify => {
                 if !cfg.quiet {
                     print_banner("evm verify");
                 }
-                commands::evm::run_verify(cfg)
+                let backend = backend_for(BackendKind::Evm);
+                backend.verify(cfg)
             }
             EvmCommands::Deploy { network } => {
                 if !cfg.quiet {
                     print_banner("evm deploy");
                 }
-                commands::evm::run_deploy(cfg, network)
+                let backend = backend_for(BackendKind::Evm);
+                backend.deploy(cfg, Some(network))
             }
             EvmCommands::Calldata => {
                 if !cfg.quiet {
                     print_banner("evm calldata");
                 }
-                commands::evm::run_calldata(cfg)
+                let backend = backend_for(BackendKind::Evm);
+                backend.calldata(cfg)
             }
             EvmCommands::VerifyOnchain => {
                 if !cfg.quiet {
                     print_banner("evm verify-onchain");
                 }
-                commands::evm::run_verify_onchain(cfg)
+                let backend = backend_for(BackendKind::Evm);
+                backend.verify_onchain(cfg, None)
             }
         },
         Commands::Doctor => {
@@ -157,7 +172,7 @@ fn dispatch(cli: &Cli, cfg: &Config) -> Result<()> {
 }
 
 fn setup_logging(verbose: bool, quiet: bool) -> Result<()> {
-    use tracing_subscriber::{fmt, EnvFilter};
+    use tracing_subscriber::{EnvFilter, fmt};
 
     if quiet {
         let subscriber = fmt()