refactor: use enum proxy pattern to improve extendability of main (#34)

* refactor: use enum pattern

* chore: lint f64 comparison

* chore: fmt stuff

Author: johnnylarner

apps/ibc-attestor/src/adapter/mod.rs

@@ -2,6 +2,10 @@ use thiserror::Error;
 
 use crate::rpc::api::CommitmentType;
 
+use cosmos::CosmosAdapter;
+use evm::EvmAdapter;
+use solana::SolanaAdapter;
+
 /// Cosmos adapter
 pub mod cosmos;
 /// EVM adapter
@@ -47,6 +51,89 @@ pub trait AdapterBuilder {
     fn build(config: Self::Config) -> Result<Self::Adapter, AttestationAdapterError>;
 }
 
+/// Enum wrapping all concrete adapter implementations.
+pub enum AdapterEnum {
+    /// EVM adapter
+    Evm(EvmAdapter),
+    /// Solana adapter
+    Solana(SolanaAdapter),
+    /// Cosmos adapter
+    Cosmos(CosmosAdapter),
+}
+
+impl AdapterEnum {
+    /// Returns the name of the adapter for logging.
+    #[must_use]
+    pub const fn adapter_name(&self) -> &'static str {
+        match self {
+            Self::Evm(_) => "evm",
+            Self::Solana(_) => "solana",
+            Self::Cosmos(_) => "cosmos",
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl AttestationAdapter for AdapterEnum {
+    async fn get_last_height_at_configured_finality(&self) -> Result<u64, AttestationAdapterError> {
+        match self {
+            Self::Evm(a) => a.get_last_height_at_configured_finality().await,
+            Self::Solana(a) => a.get_last_height_at_configured_finality().await,
+            Self::Cosmos(a) => a.get_last_height_at_configured_finality().await,
+        }
+    }
+
+    async fn get_block_timestamp(&self, height: u64) -> Result<u64, AttestationAdapterError> {
+        match self {
+            Self::Evm(a) => a.get_block_timestamp(height).await,
+            Self::Solana(a) => a.get_block_timestamp(height).await,
+            Self::Cosmos(a) => a.get_block_timestamp(height).await,
+        }
+    }
+
+    async fn get_commitment(
+        &self,
+        client_id: String,
+        height: u64,
+        sequence: u64,
+        commitment_path: &[u8],
+        commitment_type: CommitmentType,
+    ) -> Result<Option<[u8; 32]>, AttestationAdapterError> {
+        match self {
+            Self::Evm(a) => {
+                a.get_commitment(
+                    client_id,
+                    height,
+                    sequence,
+                    commitment_path,
+                    commitment_type,
+                )
+                .await
+            }
+            Self::Solana(a) => {
+                a.get_commitment(
+                    client_id,
+                    height,
+                    sequence,
+                    commitment_path,
+                    commitment_type,
+                )
+                .await
+            }
+            Self::Cosmos(a) => {
+                a.get_commitment(
+                    client_id,
+                    height,
+                    sequence,
+                    commitment_path,
+                    commitment_type,
+                )
+                .await
+            }
+        }
+    }
+}
+
 /// Attestation adapter methods needed to provide attestations for a given chain
 #[async_trait::async_trait]
 pub trait AttestationAdapter: Sync + Send + 'static {

apps/ibc-attestor/src/bin/ibc_attestor/cli.rs

@@ -1,5 +1,6 @@
 //! Defines the client interface for the attestor server.
 use clap::{Parser, ValueEnum};
+use ibc_attestor::config;
 
 /// The type of blockchain adapter to use
 #[derive(Clone, Debug, ValueEnum)]
@@ -12,6 +13,16 @@ pub enum ChainType {
     Cosmos,
 }
 
+impl From<ChainType> for config::ChainType {
+    fn from(ct: ChainType) -> Self {
+        match ct {
+            ChainType::Evm => Self::Evm,
+            ChainType::Solana => Self::Solana,
+            ChainType::Cosmos => Self::Cosmos,
+        }
+    }
+}
+
 /// The type of signer to use
 #[derive(Clone, Debug, ValueEnum)]
 pub enum SignerType {
@@ -21,6 +32,15 @@ pub enum SignerType {
     Remote,
 }
 
+impl From<SignerType> for config::SignerType {
+    fn from(st: SignerType) -> Self {
+        match st {
+            SignerType::Local => Self::Local,
+            SignerType::Remote => Self::Remote,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Parser)]
 #[command(
     name = "ibc_attestor",

apps/ibc-attestor/src/bin/ibc_attestor/main.rs

@@ -4,20 +4,10 @@ use alloy_signer_local::PrivateKeySigner;
 use clap::Parser;
 use ethereum_keys::signer_local::{read_from_keystore, write_to_keystore};
 use ibc_attestor::{
-    adapter::{
-        AdapterBuilder,
-        cosmos::{CosmosAdapterBuilder, CosmosAdapterConfig},
-        evm::{EvmAdapterBuilder, EvmAdapterConfig},
-        solana::{SolanaAdapterBuilder, SolanaAdapterConfig},
-    },
-    config::{AttestorConfig, TracingConfig},
+    config::RuntimeConfig,
     logging::init_logging,
     rpc::{RpcError, health, server},
-    signer::{
-        SignerBuilder,
-        local::{DEFAULT_KEYSTORE_NAME, LocalSigner, LocalSignerConfig},
-        remote::{RemoteSigner, RemoteSignerConfig},
-    },
+    signer::local::DEFAULT_KEYSTORE_NAME,
 };
 
 use tokio::{
@@ -27,7 +17,7 @@ use tokio::{
 };
 use tracing::info;
 
-use crate::cli::{AttestorCli, ChainType, Commands, SignerType, key::KeyCommands};
+use crate::cli::{AttestorCli, Commands, key::KeyCommands};
 
 mod cli;
 
@@ -43,12 +33,14 @@ fn default_attestor_dir() -> Result<PathBuf, anyhow::Error> {
     Ok(PathBuf::from(home).join(".ibc-attestor"))
 }
 
-fn run_servers<B: AdapterBuilder + 'static, S: SignerBuilder + 'static>(
-    config: AttestorConfig<B::Config, S::Config>,
+type ServerHandles = (JoinHandle<Result<(), RpcError>>, JoinHandle<()>);
+
+fn run_servers(
+    config: RuntimeConfig,
     shutdown_tx: &broadcast::Sender<()>,
-) -> Result<(JoinHandle<Result<(), RpcError>>, JoinHandle<()>), anyhow::Error> {
-    let adapter = B::build(config.adapter)?;
-    let signer = S::build(config.signer)?;
+) -> Result<ServerHandles, anyhow::Error> {
+    let adapter_name = config.adapter.adapter_name();
+    let signer_name = config.signer.signer_name();
     let server_config = config.server;
 
     let grpc_shutdown_rx = shutdown_tx.subscribe();
@@ -60,10 +52,10 @@ fn run_servers<B: AdapterBuilder + 'static, S: SignerBuilder + 'static>(
     let grpc_handle = tokio::spawn(async move {
         server::start(
             grpc_addr,
-            adapter,
-            B::adapter_name(),
-            signer,
-            S::signer_name(),
+            config.adapter,
+            adapter_name,
+            config.signer,
+            signer_name,
             grpc_shutdown_rx,
         )
         .await
@@ -82,55 +74,17 @@ async fn main() -> Result<(), anyhow::Error> {
 
     match cli.command {
         Commands::Server(args) => {
-            // Load tracing config first to initialize logging before parsing full config
-            let tracing_config = TracingConfig::from_file(&args.config)?;
-            let _tracing_guard = init_logging(tracing_config);
+            let config = RuntimeConfig::from_file(
+                &args.config,
+                &args.chain_type.into(),
+                &args.signer_type.into(),
+            )?;
+            let _tracing_guard = init_logging(config.tracing.clone());
 
             // Create shutdown broadcast channel
             let (shutdown_tx, _shutdown_rx) = broadcast::channel(1);
 
-            let (grpc_handle, health_handle) = match (args.chain_type, args.signer_type) {
-                (ChainType::Evm, SignerType::Local) => {
-                    let config = AttestorConfig::<EvmAdapterConfig, LocalSignerConfig>::from_file(
-                        &args.config,
-                    )?;
-                    run_servers::<EvmAdapterBuilder, LocalSigner>(config, &shutdown_tx)?
-                }
-                (ChainType::Evm, SignerType::Remote) => {
-                    let config = AttestorConfig::<EvmAdapterConfig, RemoteSignerConfig>::from_file(
-                        &args.config,
-                    )?;
-                    run_servers::<EvmAdapterBuilder, RemoteSigner>(config, &shutdown_tx)?
-                }
-                (ChainType::Solana, SignerType::Local) => {
-                    let config =
-                        AttestorConfig::<SolanaAdapterConfig, LocalSignerConfig>::from_file(
-                            &args.config,
-                        )?;
-                    run_servers::<SolanaAdapterBuilder, LocalSigner>(config, &shutdown_tx)?
-                }
-                (ChainType::Solana, SignerType::Remote) => {
-                    let config =
-                        AttestorConfig::<SolanaAdapterConfig, RemoteSignerConfig>::from_file(
-                            &args.config,
-                        )?;
-                    run_servers::<SolanaAdapterBuilder, RemoteSigner>(config, &shutdown_tx)?
-                }
-                (ChainType::Cosmos, SignerType::Local) => {
-                    let config =
-                        AttestorConfig::<CosmosAdapterConfig, LocalSignerConfig>::from_file(
-                            &args.config,
-                        )?;
-                    run_servers::<CosmosAdapterBuilder, LocalSigner>(config, &shutdown_tx)?
-                }
-                (ChainType::Cosmos, SignerType::Remote) => {
-                    let config =
-                        AttestorConfig::<CosmosAdapterConfig, RemoteSignerConfig>::from_file(
-                            &args.config,
-                        )?;
-                    run_servers::<CosmosAdapterBuilder, RemoteSigner>(config, &shutdown_tx)?
-                }
-            };
+            let (grpc_handle, health_handle) = run_servers(config, &shutdown_tx)?;
 
             _ = wait_for_shutdown_signal().await;
             info!("shutdown signal received, starting graceful shutdown");