feat: added the rest of the generators, updated some fields based on PR comments

Cargo.lock

@@ -3154,14 +3154,18 @@ dependencies = [
  "bs58",
  "cfg-if 1.0.0",
  "clap 3.2.8",
+ "coconut-bandwidth-contract-common",
+ "coconut-dkg-common",
  "comfy-table",
  "cosmrs",
  "cosmwasm-std",
+ "cw-utils",
  "handlebars",
  "humantime-serde",
  "k256",
  "log",
  "mixnet-contract-common",
+ "multisig-contract-common",
  "network-defaults",
  "rand 0.6.5",
  "serde",

common/commands/Cargo.toml

@@ -11,6 +11,7 @@ bs58 = "0.4"
 comfy-table = "6.0.0"
 cfg-if = "1.0.0"
 clap = { version = "3.2", features = ["derive"] }
+cw-utils = { version = "0.13.4" }
 handlebars = "3.0.1"
 humantime-serde = "1.0"
 k256 = { version = "0.10", features = ["ecdsa", "sha256"] }
@@ -31,3 +32,6 @@ validator-client = { path = "../client-libs/validator-client", features = ["nymd
 network-defaults = { path = "../network-defaults" }
 mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }
+coconut-bandwidth-contract-common = { path = "../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
+coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
+multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }

common/commands/src/validator/cosmwasm/generators/coconut_bandwidth.rs

@@ -0,0 +1,47 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{debug, info};
+
+use coconut_bandwidth_contract_common::msg::InstantiateMsg;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long, empty_values = false)]
+    pub pool_addr: String,
+
+    #[clap(long)]
+    pub multisig_addr: Option<String>,
+
+    #[clap(long)]
+    pub mix_denom: Option<String>,
+}
+
+pub async fn generate(args: Args) {
+    info!("Starting to generate vesting contract instantiate msg");
+
+    debug!("Received arguments: {:?}", args);
+
+    let multisig_addr = args.multisig_addr.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::REWARDING_VALIDATOR_ADDRESS)
+            .expect("Multisig address has to be set")
+    });
+
+    let mix_denom = args.mix_denom.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::MIX_DENOM).expect("Mix denom has to be set")
+    });
+
+    let instantiate_msg = InstantiateMsg {
+        pool_addr: args.pool_addr,
+        multisig_addr,
+        mix_denom,
+    };
+
+    debug!("instantiate_msg: {:?}", instantiate_msg);
+
+    let res =
+        serde_json::to_string(&instantiate_msg).expect("failed to convert instantiate msg to json");
+
+    println!("{}", res)
+}

common/commands/src/validator/cosmwasm/generators/coconut_dkg.rs

@@ -0,0 +1,51 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{debug, info};
+
+use coconut_dkg_common::msg::InstantiateMsg;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long, empty_values = false)]
+    pub group_addr: String,
+
+    #[clap(long, empty_values = false)]
+    pub admin: String,
+
+    #[clap(long)]
+    pub multisig_addr: Option<String>,
+
+    #[clap(long)]
+    pub mix_denom: Option<String>,
+}
+
+pub async fn generate(args: Args) {
+    info!("Starting to generate vesting contract instantiate msg");
+
+    debug!("Received arguments: {:?}", args);
+
+    let multisig_addr = args.multisig_addr.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::REWARDING_VALIDATOR_ADDRESS)
+            .expect("Multisig address has to be set")
+    });
+
+    let mix_denom = args.mix_denom.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::MIX_DENOM).expect("Mix denom has to be set")
+    });
+
+    let instantiate_msg = InstantiateMsg {
+        group_addr: args.group_addr,
+        admin: args.admin,
+        multisig_addr,
+        mix_denom,
+    };
+
+    debug!("instantiate_msg: {:?}", instantiate_msg);
+
+    let res =
+        serde_json::to_string(&instantiate_msg).expect("failed to convert instantiate msg to json");
+
+    println!("{}", res)
+}

common/commands/src/validator/cosmwasm/generators/mixnet.rs

@@ -10,14 +10,14 @@ use std::time::Duration;
 
 #[derive(Debug, Parser)]
 pub struct Args {
-    #[clap(long, empty_values = false)]
-    pub rewarding_validator_address: String,
+    #[clap(long)]
+    pub rewarding_validator_address: Option<String>,
 
-    #[clap(long, empty_values = false)]
-    pub vesting_contract_address: String,
+    #[clap(long)]
+    pub vesting_contract_address: Option<String>,
 
-    #[clap(long, default_value = "unymt")]
-    pub rewarding_denom: String,
+    #[clap(long)]
+    pub rewarding_denom: Option<String>,
 
     #[clap(long, default_value_t = 720)]
     pub epochs_in_interval: u32,
@@ -76,10 +76,25 @@ pub async fn generate(args: Args) {
 
     debug!("initial_rewarding_params: {:?}", initial_rewarding_params);
 
+    let rewarding_validator_address = args.rewarding_validator_address.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::REWARDING_VALIDATOR_ADDRESS)
+            .expect("Rewarding validator address has to be set")
+    });
+
+    let vesting_contract_address = args.vesting_contract_address.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::VESTING_CONTRACT_ADDRESS)
+            .expect("Vesting contract address has to be set")
+    });
+
+    let rewarding_denom = args.rewarding_denom.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::MIX_DENOM)
+            .expect("Rewarding (mix) denom has to be set")
+    });
+
     let instantiate_msg = InstantiateMsg {
-        rewarding_validator_address: args.rewarding_validator_address,
-        vesting_contract_address: args.vesting_contract_address,
-        rewarding_denom: args.rewarding_denom,
+        rewarding_validator_address,
+        vesting_contract_address,
+        rewarding_denom,
         epochs_in_interval: args.epochs_in_interval,
         epoch_duration: Duration::from_secs(args.epoch_duration),
         initial_rewarding_params,

common/commands/src/validator/cosmwasm/generators/mod.rs

@@ -3,7 +3,10 @@
 
 use clap::{Args, Subcommand};
 
+pub mod coconut_bandwidth;
+pub mod coconut_dkg;
 pub mod mixnet;
+pub mod multisig;
 pub mod vesting;
 
 #[derive(Debug, Args)]
@@ -15,6 +18,9 @@ pub struct GenerateMessage {
 
 #[derive(Debug, Subcommand)]
 pub enum GenerateMessageCommands {
+    CoconutBandwidth(coconut_bandwidth::Args),
+    CoconutDKG(coconut_dkg::Args),
     Mixnet(mixnet::Args),
+    Multisig(multisig::Args),
     Vesting(vesting::Args),
 }

common/commands/src/validator/cosmwasm/generators/multisig.rs

@@ -0,0 +1,62 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{debug, info};
+
+use cosmwasm_std::Decimal;
+use cw_utils::{Duration, Threshold};
+use multisig_contract_common::msg::InstantiateMsg;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long, empty_values = false)]
+    pub group_addr: String,
+
+    #[clap(long, default_value_t = 67)]
+    pub threshold: u128,
+
+    #[clap(long, default_value_t = 3600)]
+    pub max_voting_period: u64,
+
+    #[clap(long)]
+    pub coconut_bandwidth_contract_address: Option<String>,
+
+    #[clap(long)]
+    pub coconut_dkg_contract_address: Option<String>,
+}
+
+pub async fn generate(args: Args) {
+    info!("Starting to generate vesting contract instantiate msg");
+
+    debug!("Received arguments: {:?}", args);
+
+    let coconut_bandwidth_contract_address =
+        args.coconut_bandwidth_contract_address.unwrap_or_else(|| {
+            std::env::var(network_defaults::var_names::COCONUT_BANDWIDTH_CONTRACT_ADDRESS)
+                .expect("Coconut bandwidth contract address has to be set")
+        });
+
+    let coconut_dkg_contract_address = args.coconut_dkg_contract_address.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::COCONUT_DKG_CONTRACT_ADDRESS)
+            .expect("Coconut DKG contract address has to be set")
+    });
+
+    let instantiate_msg = InstantiateMsg {
+        group_addr: args.group_addr,
+        threshold: Threshold::AbsolutePercentage {
+            percentage: Decimal::from_atomics(args.threshold, 2)
+                .expect("threshold can't be converted to Decimal"),
+        },
+        max_voting_period: Duration::Time(args.max_voting_period),
+        coconut_bandwidth_contract_address,
+        coconut_dkg_contract_address,
+    };
+
+    debug!("instantiate_msg: {:?}", instantiate_msg);
+
+    let res =
+        serde_json::to_string(&instantiate_msg).expect("failed to convert instantiate msg to json");
+
+    println!("{}", res)
+}

common/commands/src/validator/cosmwasm/generators/vesting.rs

@@ -8,11 +8,11 @@ use vesting_contract_common::InitMsg;
 
 #[derive(Debug, Parser)]
 pub struct Args {
-    #[clap(long, empty_values = false)]
-    pub mixnet_contract_address: String,
+    #[clap(long)]
+    pub mixnet_contract_address: Option<String>,
 
-    #[clap(long, default_value = "unymt", empty_values = false)]
-    pub mix_denom: String,
+    #[clap(long)]
+    pub mix_denom: Option<String>,
 }
 
 pub async fn generate(args: Args) {
@@ -20,9 +20,18 @@ pub async fn generate(args: Args) {
 
     debug!("Received arguments: {:?}", args);
 
+    let mixnet_contract_address = args.mixnet_contract_address.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::MIXNET_CONTRACT_ADDRESS)
+            .expect("Mixnet contract address has to be set")
+    });
+
+    let mix_denom = args.mix_denom.unwrap_or_else(|| {
+        std::env::var(network_defaults::var_names::MIX_DENOM).expect("Mix denom has to be set")
+    });
+
     let instantiate_msg = InitMsg {
-        mixnet_contract_address: args.mixnet_contract_address,
-        mix_denom: args.mix_denom,
+        mixnet_contract_address,
+        mix_denom,
     };
 
     debug!("instantiate_msg: {:?}", instantiate_msg);

tools/nym-cli/src/validator/cosmwasm/generators/mod.rs

@@ -9,6 +9,18 @@ pub(crate) async fn execute(
         nym_cli_commands::validator::cosmwasm::generators::GenerateMessageCommands::Vesting(
             args,
         ) => nym_cli_commands::validator::cosmwasm::generators::vesting::generate(args).await,
+
+        nym_cli_commands::validator::cosmwasm::generators::GenerateMessageCommands::CoconutBandwidth(
+            args,
+        ) => nym_cli_commands::validator::cosmwasm::generators::coconut_bandwidth::generate(args).await,
+
+        nym_cli_commands::validator::cosmwasm::generators::GenerateMessageCommands::CoconutDKG(
+            args,
+        ) => nym_cli_commands::validator::cosmwasm::generators::coconut_dkg::generate(args).await,
+
+        nym_cli_commands::validator::cosmwasm::generators::GenerateMessageCommands::Multisig(
+            args,
+        ) => nym_cli_commands::validator::cosmwasm::generators::multisig::generate(args).await,
     }
     Ok(())
 }