Change config format to scope configs by type

crates/relayer-cli/src/chain_registry.rs

@@ -19,7 +19,9 @@ use ibc_chain_registry::querier::*;
 use ibc_relayer::config::filter::{FilterPattern, PacketFilter};
 use ibc_relayer::config::gas_multiplier::GasMultiplier;
 use ibc_relayer::config::types::{MaxMsgNum, MaxTxSize, Memo};
-use ibc_relayer::config::{default, AddressType, ChainConfig, EventSourceMode, GasPrice};
+use ibc_relayer::config::{
+    default, AddressType, ChainConfig, CosmosSdkConfig, EventSourceMode, GasPrice,
+};
 use ibc_relayer::keyring::Store;
 
 use tendermint_light_client_verifier::types::TrustThreshold;
@@ -120,9 +122,8 @@ where
         0.1
     };
 
-    Ok(ChainConfig {
+    Ok(ChainConfig::CosmosSdk(CosmosSdkConfig {
         id: chain_data.chain_id,
-        r#type: default::chain_type(),
         rpc_addr: rpc_data.rpc_address,
         grpc_addr: grpc_address,
         event_source: EventSourceMode::Push {
@@ -160,7 +161,7 @@ where
         address_type: AddressType::default(),
         sequential_batch_tx: false,
         extension_options: Vec::new(),
-    })
+    }))
 }
 
 /// Concurrent `query_healthy` might fail, this is a helper function which will retry a failed query a fixed
@@ -341,7 +342,10 @@ mod tests {
         for config in configs {
             match config {
                 Ok(config) => {
-                    assert_eq!(config.packet_filter.channel_policy, ChannelPolicy::AllowAll);
+                    assert_eq!(
+                        config.packet_filter().channel_policy,
+                        ChannelPolicy::AllowAll
+                    );
                 }
                 Err(e) => panic!(
                     "Encountered an unexpected error in chain registry test: {}",
@@ -367,9 +371,9 @@ mod tests {
 
         for config in configs {
             match config {
-                Ok(config) => match config.packet_filter.channel_policy {
+                Ok(config) => match config.packet_filter().channel_policy {
                     ChannelPolicy::Allow(channel_filter) => {
-                        if config.id.as_str().contains("cosmoshub") {
+                        if config.id().as_str().contains("cosmoshub") {
                             assert!(channel_filter.is_exact());
 
                             let cosmoshub_juno = (
@@ -385,7 +389,7 @@ mod tests {
                             assert!(channel_filter.matches(cosmoshub_juno));
                             assert!(channel_filter.matches(cosmoshub_osmosis));
                             assert!(channel_filter.len() == 2);
-                        } else if config.id.as_str().contains("juno") {
+                        } else if config.id().as_str().contains("juno") {
                             assert!(channel_filter.is_exact());
 
                             let juno_cosmoshub = (
@@ -407,7 +411,7 @@ mod tests {
                             assert!(channel_filter.matches(juno_osmosis_1));
                             assert!(channel_filter.matches(juno_osmosis_2));
                             assert!(channel_filter.len() == 3);
-                        } else if config.id.as_str().contains("osmosis") {
+                        } else if config.id().as_str().contains("osmosis") {
                             assert!(channel_filter.is_exact());
 
                             let osmosis_cosmoshub = (

crates/relayer-cli/src/commands.rs

@@ -32,7 +32,7 @@ use abscissa_core::{config::Override, Command, Configurable, FrameworkError, Run
 use tracing::{error, info};
 
 use crate::DEFAULT_CONFIG_PATH;
-use ibc_relayer::config::Config;
+use ibc_relayer::config::{ChainConfig, Config};
 
 /// Default configuration file path
 pub fn default_config_file() -> Option<PathBuf> {
@@ -145,14 +145,18 @@ impl Configurable<Config> for CliCmd {
         let web = "https://hermes.informal.systems";
         let suffix = format!("{} {} ({})", CliCmd::name(), clap::crate_version!(), web);
         for ccfg in config.chains.iter_mut() {
-            ccfg.memo_prefix.apply_suffix(&suffix);
+            if let ChainConfig::CosmosSdk(ref mut cosmos_ccfg) = ccfg {
+                cosmos_ccfg.memo_prefix.apply_suffix(&suffix);
+            }
         }
 
         // For all commands except for `start` Hermes retries
         // for a prolonged period of time.
         if !matches!(self, CliCmd::Start(_)) {
             for c in config.chains.iter_mut() {
-                c.rpc_timeout = Duration::from_secs(120);
+                if let ChainConfig::CosmosSdk(ref mut cosmos_ccfg) = c {
+                    cosmos_ccfg.rpc_timeout = Duration::from_secs(120);
+                }
             }
         }
 

crates/relayer-cli/src/commands/clear.rs

@@ -75,7 +75,12 @@
         })?;
 
         if let Some(ref key_name) = self.key_name {
+            // Q: should the key name be required across chain types, meaning that
+            // key management is common to all chain types, or should key management
+            // be the responsibility of the backend? If key management is common
+            // across backends, how should it be agnostic to the key type? Can it
+            // just be an opaque byte string handled by the backend?
             chain_config.key_name = key_name.to_string();
         }
 
         Ok(config)
@@ -101,7 +106,7 @@
         if let Some(ref counterparty_key_name) = self.counterparty_key_name {
             match chains.dst.config() {
                 Ok(mut dst_chain_cfg) => {
                     dst_chain_cfg.key_name = counterparty_key_name.to_string();
                 }
                 Err(e) => Output::error(e).exit(),
             }

crates/relayer-cli/src/commands/config/auto.rs

@@ -117,7 +117,7 @@
             .collect();
 
         // Determine which chains were not fetched
         let fetched_chains_set = HashSet::from_iter(chain_configs.iter().map(|c| c.id.name()));
         let missing_chains_set: HashSet<_> =
             sorted_names_set.difference(&fetched_chains_set).collect();
 
@@ -128,15 +128,15 @@
         for (chain_config, key_option) in configs_and_keys {
             // If a key is provided, use it
             if let Some(key_name) = key_option {
-                info!("{}: uses key \"{}\"", &chain_config.id, &key_name);
+                info!("{}: uses key \"{}\"", &chain_config.id(), &key_name);
                 chain_config.key_name = key_name;
             } else {
                 // Otherwise, find the key in the keystore
-                let chain_id = &chain_config.id;
+                let chain_id = &chain_config.id();
                 let key = find_key(chain_config);
                 if let Some(key) = key {
                     info!("{}: uses key '{}'", &chain_id, &key);
                     chain_config.key_name = key;
                 } else {
                     // If no key is found, warn the user and continue
                     warn!("No key found for chain: {}", chain_id);

crates/relayer-cli/src/commands/health.rs

@@ -16,12 +16,12 @@ impl Runnable for HealthCheckCmd {
         let config = app_config();
 
         for ch in &config.chains {
-            let _span = tracing::error_span!("health_check", chain = %ch.id).entered();
+            let _span = tracing::error_span!("health_check", chain = %ch.id()).entered();
 
             info!("performing health check...");
 
-            let chain =
-                spawn_chain_runtime(&config, &ch.id).unwrap_or_else(exit_with_unrecoverable_error);
+            let chain = spawn_chain_runtime(&config, &ch.id())
+                .unwrap_or_else(exit_with_unrecoverable_error);
 
             match chain.health_check() {
                 Ok(Healthy) => info!("chain is healthy"),

crates/relayer-cli/src/commands/keys/add.rs

@@ -10,7 +10,6 @@
 use eyre::eyre;
 use hdpath::StandardHDPath;
 use ibc_relayer::{
-    chain::ChainType,
     config::{ChainConfig, Config},
     keyring::{
         AnySigningKeyPair, KeyRing, Secp256k1KeyPair, SigningKeyPair, SigningKeyPairSized, Store,
@@ -107,7 +106,7 @@
         let hd_path = StandardHDPath::from_str(&self.hd_path)
             .map_err(|_| eyre!("invalid derivation path: {}", self.hd_path))?;
 
         Ok(KeysAddOptions {
             config: chain_config.clone(),
             name,
             hd_path,
@@ -146,7 +145,7 @@
                         "Added key '{}' ({}) on chain {}",
                         opts.name,
                         key.account(),
-                        opts.config.id
+                        opts.config.id(),
                     ))
                     .exit(),
                     Err(e) => Output::error(format!(
@@ -170,7 +169,7 @@
                         "Restored key '{}' ({}) on chain {}",
                         opts.name,
                         key.account(),
-                        opts.config.id
+                        opts.config.id()
                     ))
                     .exit(),
                     Err(e) => Output::error(format!(
@@ -198,8 +197,8 @@
     hd_path: &StandardHDPath,
     overwrite: bool,
 ) -> eyre::Result<AnySigningKeyPair> {
-    let key_pair = match config.r#type {
-        ChainType::CosmosSdk => {
+    let key_pair = match config {
+        ChainConfig::CosmosSdk(config) => {
             let mut keyring = KeyRing::new_secp256k1(
                 Store::Test,
                 &config.account_prefix,
@@ -231,8 +230,8 @@
     let mnemonic_content =
         fs::read_to_string(mnemonic).map_err(|_| eyre!("error reading the mnemonic file"))?;
 
-    let key_pair = match config.r#type {
-        ChainType::CosmosSdk => {
+    let key_pair = match config {
+        ChainConfig::CosmosSdk(config) => {
             let mut keyring = KeyRing::new_secp256k1(
                 Store::Test,
                 &config.account_prefix,

crates/relayer-cli/src/commands/keys/delete.rs

@@ -3,7 +3,6 @@
 
 use eyre::eyre;
 use ibc_relayer::{
-    chain::ChainType,
     config::{ChainConfig, Config},
     keyring::{KeyRing, Store},
 };
@@ -95,7 +94,7 @@
         match opts.id {
             KeysDeleteId::All => match delete_all_keys(&opts.config) {
                 Ok(_) => {
                     Output::success_msg(format!("Removed all keys on chain {}", opts.config.id))
                         .exit()
                 }
                 Err(e) => Output::error(e).exit(),
@@ -103,7 +102,8 @@
             KeysDeleteId::Named(key_name) => match delete_key(&opts.config, key_name) {
                 Ok(_) => Output::success_msg(format!(
                     "Removed key ({}) on chain {}",
-                    key_name, opts.config.id
+                    key_name,
+                    opts.config.id(),
                 ))
                 .exit(),
                 Err(e) => Output::error(e).exit(),
@@ -113,8 +113,8 @@
 }
 
 pub fn delete_key(config: &ChainConfig, key_name: &str) -> eyre::Result<()> {
-    match config.r#type {
-        ChainType::CosmosSdk => {
+    match config {
+        ChainConfig::CosmosSdk(config) => {
             let mut keyring = KeyRing::new_secp256k1(
                 Store::Test,
                 &config.account_prefix,
@@ -128,8 +128,8 @@
 }
 
 pub fn delete_all_keys(config: &ChainConfig) -> eyre::Result<()> {
-    match config.r#type {
-        ChainType::CosmosSdk => {
+    match config {
+        ChainConfig::CosmosSdk(config) => {
             let mut keyring = KeyRing::new_secp256k1(
                 Store::Test,
                 &config.account_prefix,

crates/relayer-cli/src/commands/listen.rs

@@ -102,7 +102,7 @@ impl Runnable for ListenCmd {
 }
 
 /// Listen to events
-#[instrument(skip_all, level = "error", fields(chain = %config.id))]
+#[instrument(skip_all, level = "error", fields(chain = %config.id()))]
 pub fn listen(config: &ChainConfig, filters: &[EventFilter]) -> eyre::Result<()> {
     let rt = Arc::new(TokioRuntime::new()?);
     let compat_mode = detect_compatibility_mode(config, rt.clone())?;
@@ -144,6 +144,8 @@ fn subscribe(
     compat_mode: CompatMode,
     rt: Arc<TokioRuntime>,
 ) -> eyre::Result<Subscription> {
+    // Q: Should this be restricted only to backends that support it,
+    // or are all backends expected to support subscriptions?
     let (event_source, monitor_tx) = match &chain_config.event_source {
         EventSourceMode::Push { url, batch_delay } => EventSource::websocket(
             chain_config.id.clone(),
@@ -166,6 +168,7 @@ fn subscribe(
     Ok(subscription)
 }
 
+// Q: why isn't this part of the CosmosSDK chain endpoint impl?
 fn detect_compatibility_mode(
     config: &ChainConfig,
     rt: Arc<TokioRuntime>,

crates/relayer-cli/src/commands/tx/client.rs

@@ -203,6 +203,8 @@ impl Runnable for TxUpdateClientCmd {
 
         if let Some(restart_params) = self.genesis_restart_params() {
             if let Some(c) = config.find_chain_mut(&reference_chain_id) {
+                // Q: How should this be handled? Should the cli command only
+                // work on supported chain types?
                 c.genesis_restart = Some(restart_params);
             }
         }
@@ -435,14 +437,14 @@ impl Runnable for TxUpgradeClientsCmd {
             .chains
             .iter()
             .filter_map(|chain| {
-                (self.reference_chain_id != chain.id
+                (self.reference_chain_id != *chain.id()
                     && (self.host_chain_id.is_none()
-                        || self.host_chain_id == Some(chain.id.clone())))
+                        || self.host_chain_id == Some(chain.id().clone())))
                 .then(|| {
                     self.upgrade_clients_for_chain(
                         &config,
                         reference_chain.clone(),
-                        &chain.id,
+                        &chain.id(),
                         reference_upgrade_height,
                     )
                 })

crates/relayer-cli/src/config.rs

@@ -8,7 +8,7 @@ use alloc::collections::BTreeSet;
 use std::path::PathBuf;
 
 use flex_error::{define_error, TraceError};
-use ibc_relayer::config::{ChainConfig, Config, ModeConfig};
+use ibc_relayer::config::{ChainConfig, Config, CosmosSdkConfig, ModeConfig};
 use ibc_relayer_types::core::ics24_host::identifier::ChainId;
 use tendermint_light_client_verifier::types::TrustThreshold;
 use tracing_subscriber::filter::ParseError;
@@ -87,15 +87,18 @@ pub fn validate_config(config: &Config) -> Result<(), Diagnostic<Error>> {
     // Check for duplicate chain configuration and invalid trust thresholds
     let mut unique_chain_ids = BTreeSet::new();
     for c in config.chains.iter() {
-        let already_present = !unique_chain_ids.insert(c.id.clone());
+        let already_present = !unique_chain_ids.insert(c.id().clone());
         if already_present {
-            return Err(Diagnostic::Error(Error::duplicate_chains(c.id.clone())));
+            return Err(Diagnostic::Error(Error::duplicate_chains(c.id().clone())));
         }
 
-        validate_trust_threshold(&c.id, c.trust_threshold)?;
-
-        // Validate gas-related settings
-        validate_gas_settings(&c.id, c)?;
+        // TODO: why are these not methods on the config object?
+        // why are they defined only in the relayer-cli crate?
+        if let ChainConfig::CosmosSdk(cosmos_c) = c {
+            validate_trust_threshold(&cosmos_c.id, cosmos_c.trust_threshold)?;
+            // Validate gas-related settings
+            validate_gas_settings(&cosmos_c.id, cosmos_c)?;
+        }
     }
 
     // Check for invalid mode config
@@ -156,7 +159,7 @@ fn validate_trust_threshold(
     Ok(())
 }
 
-fn validate_gas_settings(id: &ChainId, config: &ChainConfig) -> Result<(), Diagnostic<Error>> {
+fn validate_gas_settings(id: &ChainId, config: &CosmosSdkConfig) -> Result<(), Diagnostic<Error>> {
     // Check that the gas_adjustment option is not set
     if let Some(gas_adjustment) = config.gas_adjustment {
         let gas_multiplier = gas_adjustment + 1.0;

crates/relayer/src/chain.rs

@@ -6,60 +6,3 @@ pub mod handle;
 pub mod requests;
 pub mod runtime;
 pub mod tracking;
-
-use serde::{de::Error, Deserialize, Serialize};
-
-// NOTE(new): When adding a variant to `ChainType`, make sure to update
-//            the `Deserialize` implementation below and the tests.
-//            See the NOTE(new) comments below.
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize)]
-/// Types of chains the relayer can relay to and from
-pub enum ChainType {
-    /// Chains based on the Cosmos SDK
-    CosmosSdk,
-}
-
-impl<'de> Deserialize<'de> for ChainType {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let original = String::deserialize(deserializer)?;
-        let s = original.to_ascii_lowercase().replace('-', "");
-
-        match s.as_str() {
-            "cosmossdk" => Ok(Self::CosmosSdk),
-
-            // NOTE(new): Add a case here
-            _ => Err(D::Error::unknown_variant(&original, &["cosmos-sdk"])), // NOTE(new): mention the new variant here
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-    pub struct Config {
-        tpe: ChainType,
-    }
-
-    fn parse(variant: &str) -> Result<ChainType, toml::de::Error> {
-        toml::from_str::<Config>(&format!("tpe = '{variant}'")).map(|e| e.tpe)
-    }
-
-    #[test]
-    fn deserialize() {
-        use ChainType::*;
-
-        assert!(matches!(parse("CosmosSdk"), Ok(CosmosSdk)));
-        assert!(matches!(parse("cosmossdk"), Ok(CosmosSdk)));
-        assert!(matches!(parse("cosmos-sdk"), Ok(CosmosSdk)));
-
-        // NOTE(new): Add tests here
-
-        assert!(parse("hello-world").is_err());
-    }
-}