Merge pull request #59 from fpco/config-cw3-contracts

Allow for configuration of code IDs

Author: anakinzhed

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};