Allow for configuration of code IDs

This moves the handling of configured code IDs into the core library instead of the executable. Instead of simply hard-coding them, it uses the same configuration system as other values. This allows us to provide code IDs for custom networks or override the defaults.

This also adds CLI options for providing code IDs when generating a new CW3 flex contract.

Author: snoyberg

packages/cosmos-bin/src/config.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use anyhow::Result;
-use cosmos::{AddressHrp, CosmosConfig, CosmosConfigError};
+use cosmos::{AddressHrp, ContractType, CosmosConfig, CosmosConfigError};
 
 #[derive(clap::Parser)]
 pub(crate) enum Opt {
@@ -46,6 +46,15 @@ pub(crate) enum Opt {
         /// gRPC URL
         url: String,
     },
+    /// Add a recognized contract code ID
+    AddContract {
+        /// Network name
+        name: String,
+        /// Contract type
+        contract_type: ContractType,
+        /// Code ID
+        code_id: u64,
+    },
 }
 
 // Strum would be more approriate, but serde gives better error messages
@@ -128,5 +137,16 @@ pub(crate) fn go(opt: crate::cli::Opt, inner: Opt) -> Result<()> {
             println!("Changes saved");
             Ok(())
         }
+        Opt::AddContract {
+            name,
+            contract_type,
+            code_id,
+        } => {
+            let mut config = load(&opt)?;
+            config.add_contract(name, contract_type, code_id);
+            config.save()?;
+            println!("Changes saved");
+            Ok(())
+        }
     }
 }

packages/cosmos-bin/src/cw3.rs

@@ -1,7 +1,7 @@
 use anyhow::{Context, Result};
 use cosmos::{
-    proto::cosmos::bank::v1beta1::MsgSend, Address, ContractAdmin, Cosmos, HasAddress,
-    HasAddressHrp, ParsedCoin, TxBuilder,
+    proto::cosmos::bank::v1beta1::MsgSend, Address, ContractAdmin, ContractType, Cosmos,
+    HasAddress, HasAddressHrp, ParsedCoin, TxBuilder,
 };
 use cosmwasm_std::{to_json_binary, CosmosMsg, Decimal, Empty, WasmMsg};
 use cw3::{ProposalListResponse, ProposalResponse};
@@ -10,30 +10,6 @@ use cw_utils::Threshold;
 
 use crate::{cli::TxOpt, my_duration::MyDuration};
 
-#[derive(Clone, Copy, Debug)]
-enum ContractType {
-    Cw3Flex,
-    Cw4Group,
-}
-
-fn get_code_id(chain_id: &str, contract_type: ContractType) -> Result<u64> {
-    match (chain_id, contract_type) {
-        ("osmo-test-5", ContractType::Cw3Flex) => Ok(1519),
-        ("osmo-test-5", ContractType::Cw4Group) => Ok(1521),
-        ("osmosis-1", ContractType::Cw3Flex) => Ok(100),
-        ("osmosis-1", ContractType::Cw4Group) => Ok(101),
-        ("pacific-1", ContractType::Cw3Flex) => Ok(46),
-        ("pacific-1", ContractType::Cw4Group) => Ok(47),
-        ("injective-1", ContractType::Cw3Flex) => Ok(124),
-        ("injective-1", ContractType::Cw4Group) => Ok(125),
-        ("neutron-1", ContractType::Cw3Flex) => Ok(1189),
-        ("neutron-1", ContractType::Cw4Group) => Ok(1190),
-        _ => Err(anyhow::anyhow!(
-            "No code ID found for combo {chain_id}/{contract_type:?}"
-        )),
-    }
-}
-
 #[derive(clap::Parser)]
 pub(crate) struct Opt {
     #[clap(subcommand)]
@@ -124,6 +100,12 @@ struct NewFlexOpt {
     /// Duration. Accepts s, m, h, and d suffixes for seconds, minutes, hours, and days
     #[clap(long)]
     duration: MyDuration,
+    /// Code ID for the CW3 flex contract
+    #[clap(long)]
+    cw3_flex_code_id: Option<u64>,
+    /// Code ID for the CW4 group contract
+    #[clap(long)]
+    cw4_group_code_id: Option<u64>,
 }
 
 async fn new_flex(
@@ -135,12 +117,17 @@ async fn new_flex(
         cw4_label,
         weight_needed,
         duration,
+        cw3_flex_code_id,
+        cw4_group_code_id,
     }: NewFlexOpt,
 ) -> Result<()> {
-    let chain_id = cosmos.get_cosmos_builder().chain_id();
     let wallet = tx_opt.get_wallet(cosmos.get_address_hrp())?;
-    let cw3 = cosmos.make_code_id(get_code_id(chain_id, ContractType::Cw3Flex)?);
-    let cw4 = cosmos.make_code_id(get_code_id(chain_id, ContractType::Cw4Group)?);
+    let cw3 = cosmos.make_code_id(
+        cw3_flex_code_id.map_or_else(|| cosmos.get_code_id_for(ContractType::Cw3Flex), Ok)?,
+    );
+    let cw4 = cosmos.make_code_id(
+        cw4_group_code_id.map_or_else(|| cosmos.get_code_id_for(ContractType::Cw4Group), Ok)?,
+    );
 
     anyhow::ensure!(!members.is_empty(), "Must provide at least one member");
 

packages/cosmos/src/codeid.rs

@@ -151,3 +151,44 @@ impl HasAddressHrp for CodeId {
         self.client.get_address_hrp()
     }
 }
+
+/// A type of contract which is understood by this library.
+///
+/// This is used to allow configuring generally reusable contracts like CW3 multisigs.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    serde::Serialize,
+    serde::Deserialize,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    strum_macros::AsRefStr,
+    strum_macros::Display,
+    strum_macros::EnumString,
+)]
+#[serde(rename_all = "kebab-case")]
+#[strum(serialize_all = "kebab-case")]
+#[non_exhaustive]
+pub enum ContractType {
+    /// CW3 flex multisig contract
+    Cw3Flex,
+    /// CW4 group contract
+    Cw4Group,
+}
+
+impl Cosmos {
+    /// Get the configured code ID for the given contract type.
+    ///
+    /// Returns an error if no such contract type is configured.
+    pub fn get_code_id_for(&self, contract_type: ContractType) -> crate::Result<u64> {
+        self.get_cosmos_builder()
+            .code_ids
+            .get(&contract_type)
+            .copied()
+            .ok_or(crate::Error::ContractTypeNotConfigured { contract_type })
+    }
+}

packages/cosmos/src/config.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::HashMap,
+    collections::{BTreeMap, HashMap},
     path::{Path, PathBuf},
     str::FromStr,
 };
@@ -9,7 +9,7 @@ use figment::{
     Figment,
 };
 
-use crate::{AddressHrp, CosmosBuilder, CosmosNetwork};
+use crate::{AddressHrp, ContractType, CosmosBuilder, CosmosNetwork};
 
 /// Configuration overrides for individual network
 #[derive(Debug)]
@@ -34,6 +34,8 @@ struct NetworkConfig {
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     grpc_fallbacks: Vec<String>,
     gas_multiplier: Option<f64>,
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    code_ids: BTreeMap<ContractType, u64>,
 }
 
 impl NetworkConfig {
@@ -50,11 +52,17 @@ impl NetworkConfig {
         if let Some(hrp) = self.hrp {
             builder.set_hrp(hrp);
         }
+        for (contract_type, code_id) in &self.code_ids {
+            builder.set_code_id(*contract_type, *code_id);
+        }
     }
     fn apply_extra_config(&self, builder: &mut CosmosBuilder) {
         for fallback in &self.grpc_fallbacks {
             builder.add_grpc_fallback_url(fallback);
         }
+        for (contract_type, code_id) in &self.code_ids {
+            builder.set_code_id(*contract_type, *code_id);
+        }
         if let Some(gas_multiplier) = self.gas_multiplier {
             builder.set_gas_estimate_multiplier(gas_multiplier)
         }
@@ -203,6 +211,7 @@ impl CosmosConfig {
                 hrp,
                 grpc_fallbacks,
                 gas_multiplier,
+                code_ids,
             },
         ) in networks
         {
@@ -226,6 +235,9 @@ impl CosmosConfig {
             if let Some(gas_multiplier) = gas_multiplier {
                 println!("Gas multiplier: {gas_multiplier}");
             }
+            for (contract_type, code_id) in code_ids {
+                println!("Code ID for {contract_type}: {code_id}");
+            }
         }
     }
 
@@ -247,6 +259,7 @@ impl CosmosConfig {
                 hrp: Some(hrp),
                 grpc_fallbacks: vec![],
                 gas_multiplier: None,
+                code_ids: BTreeMap::new(),
             },
         );
     }
@@ -302,6 +315,16 @@ impl CosmosConfig {
             .grpc_fallbacks
             .push(url);
     }
+
+    /// Add a new contract type/code ID mapping.
+    pub fn add_contract(&mut self, name: String, contract_type: ContractType, code_id: u64) {
+        self.inner
+            .network
+            .entry(name)
+            .or_default()
+            .code_ids
+            .insert(contract_type, code_id);
+    }
 }
 
 impl CosmosNetwork {

packages/cosmos/src/cosmos_builder.rs

@@ -1,9 +1,9 @@
-use std::{sync::Arc, time::Duration};
+use std::{collections::BTreeMap, sync::Arc, time::Duration};
 
 use crate::{
     gas_multiplier::{GasMultiplier, GasMultiplierConfig},
     gas_price::GasPriceMethod,
-    AddressHrp, DynamicGasMultiplier,
+    AddressHrp, ContractType, DynamicGasMultiplier,
 };
 
 #[derive(Clone, Copy, Debug)]
@@ -50,6 +50,7 @@ pub struct CosmosBuilder {
     keep_alive_while_idle: Option<bool>,
     simulate_with_gas_coin: bool,
     delay_before_fallback: Option<tokio::time::Duration>,
+    pub(crate) code_ids: BTreeMap<ContractType, u64>,
 }
 
 impl CosmosBuilder {
@@ -96,6 +97,7 @@ impl CosmosBuilder {
             keep_alive_while_idle: None,
             simulate_with_gas_coin,
             delay_before_fallback: None,
+            code_ids: BTreeMap::new(),
         }
     }
 
@@ -155,6 +157,11 @@ impl CosmosBuilder {
         self.hrp = hrp;
     }
 
+    /// Set a code ID for the given contract type.
+    pub fn set_code_id(&mut self, contract_type: ContractType, code_id: u64) {
+        self.code_ids.insert(contract_type, code_id);
+    }
+
     /// Revert to the default gas multiplier value (static value of 1.3).
     ///
     /// This value comes from CosmJS and OsmoJS:

packages/cosmos/src/cosmos_network.rs

@@ -3,7 +3,10 @@ use std::{collections::HashMap, str::FromStr};
 use serde::de::Visitor;
 use strum_macros::{EnumString, IntoStaticStr};
 
-use crate::{error::BuilderError, gas_price::GasPriceMethod, Cosmos, CosmosBuilder, HasAddressHrp};
+use crate::{
+    error::BuilderError, gas_price::GasPriceMethod, ContractType, Cosmos, CosmosBuilder,
+    HasAddressHrp,
+};
 
 /// A set of known networks.
 ///
@@ -210,6 +213,30 @@ impl CosmosNetwork {
                 builder.set_gas_price(500000000.0, 900000000.0);
             }
         }
+
+        match self {
+            CosmosNetwork::OsmosisMainnet => {
+                builder.set_code_id(ContractType::Cw3Flex, 100);
+                builder.set_code_id(ContractType::Cw4Group, 101);
+            }
+            CosmosNetwork::OsmosisTestnet => {
+                builder.set_code_id(ContractType::Cw3Flex, 1519);
+                builder.set_code_id(ContractType::Cw4Group, 1521);
+            }
+            CosmosNetwork::SeiMainnet => {
+                builder.set_code_id(ContractType::Cw3Flex, 46);
+                builder.set_code_id(ContractType::Cw4Group, 47);
+            }
+            CosmosNetwork::InjectiveMainnet => {
+                builder.set_code_id(ContractType::Cw3Flex, 124);
+                builder.set_code_id(ContractType::Cw4Group, 125);
+            }
+            CosmosNetwork::NeutronMainnet => {
+                builder.set_code_id(ContractType::Cw3Flex, 1189);
+                builder.set_code_id(ContractType::Cw4Group, 1190);
+            }
+            _ => (),
+        }
     }
 
     /// Load settings, like gas fees, from the internet.

packages/cosmos/src/error.rs

@@ -9,7 +9,7 @@ use chrono::{DateTime, Utc};
 use cosmos_sdk_proto::cosmos::tx::v1beta1::OrderBy;
 use http::uri::InvalidUri;
 
-use crate::{Address, AddressHrp, CosmosBuilder, TxBuilder};
+use crate::{Address, AddressHrp, ContractType, CosmosBuilder, TxBuilder};
 
 /// Errors that can occur with token factory
 #[derive(thiserror::Error, Debug, Clone)]
@@ -344,6 +344,9 @@ pub enum Error {
     WasmGzipFailed {
         source: std::io::Error,
     },
+    ContractTypeNotConfigured {
+        contract_type: ContractType,
+    },
 }
 
 impl Display for Error {
@@ -411,6 +414,9 @@ impl Error {
             Error::WasmGzipFailed { source } => {
                 write!(f, "Error during wasm Gzip compression: {source}")
             }
+            Error::ContractTypeNotConfigured { contract_type } => {
+                write!(f, "Contract type not configured: {contract_type}")
+            }
         }
     }
 

packages/cosmos/src/lib.rs

@@ -2,7 +2,7 @@
 //! Library for communicating with Cosmos blockchains over gRPC
 pub use address::{Address, AddressHrp, HasAddress, HasAddressHrp, PublicKeyMethod, RawAddress};
 pub use client::{BlockInfo, Cosmos, CosmosTxResponse, HasCosmos};
-pub use codeid::CodeId;
+pub use codeid::{CodeId, ContractType};
 #[cfg(feature = "config")]
 pub use config::{CosmosConfig, CosmosConfigError};
 pub use contract::{Contract, ContractAdmin, HasContract};