yep

Author: 0xForerunner

wasm-deploy/Cargo.toml

@@ -18,7 +18,7 @@ wasm_cli = []
 [dependencies]
 wasm-deploy-derive = { version = "0.6.0", path = "../wasm-deploy-derive" }
 cosm-utils = { path = "../../cosm-utils", features = ["keyring"] }
-tendermint-rpc = "0.38"
+# tendermint-rpc = "0.38"
 wasm-opt = { version = "=0.110.2", optional = true }
 serde = { version = "1", default-features = false, features = ["derive"] }
 serde_json = "1"

wasm-deploy/src/cli.rs

@@ -156,6 +156,10 @@ where
         #[arg(short, long, required = false)]
         interactive: bool,
 
+        /// Will prompt for coins for each message
+        #[arg(long, required = false)]
+        coins: bool,
+
         /// Does not execute transactions, prints txs to console
         #[arg(short, long, required = false)]
         dry_run: bool,
@@ -238,6 +242,21 @@ where
         dry_run: bool,
     },
 
+    /// Sends a token amount to a given address
+    Cw20Transfer {
+        /// Address to receive the tokens
+        #[arg(long)]
+        recipient: String,
+
+        /// The amount and denom to send
+        #[arg(short, long)]
+        contract_addr: String,
+
+        /// The amount and denom to send
+        #[arg(long)]
+        amount: u128,
+    },
+
     /// Executes a contract with a custom payload
     ExecutePayload {
         #[arg(short, long)]

wasm-deploy/src/commands.rs

@@ -11,25 +11,27 @@ use clap_complete::{
 use colored::Colorize;
 use colored_json::to_colored_json_auto;
 use cosm_utils::chain::coin::Denom;
+use cosm_utils::cosmrs;
 use cosm_utils::modules::bank::model::SendRequest;
 use cosm_utils::prelude::*;
 use cosm_utils::{
     chain::{coin::Coin, request::TxOptions},
     modules::{auth::model::Address, cosmwasm::model::ExecRequest},
 };
+use cosmrs::rpc::client::CompatMode;
+use cosmrs::rpc::{HttpClient, HttpClientUrl};
 #[cfg(feature = "wasm_opt")]
 use futures::future::join_all;
 use inquire::{MultiSelect, Select};
 use interactive_parse::InteractiveParseObj;
 use log::info;
-use tendermint_rpc::client::CompatMode;
-use tendermint_rpc::{HttpClient, HttpClientUrl};
 #[cfg(feature = "wasm_opt")]
 use tokio::task::spawn_blocking;
 #[cfg(feature = "wasm_opt")]
 use wasm_opt::integration::run_from_command_args;
 
 use crate::config::WorkspaceSettings;
+use crate::cw20::cw20_transfer;
 use crate::query::query;
 use crate::utils::print_res;
 #[cfg(wasm_cli)]
@@ -90,8 +92,9 @@ where
         Commands::Instantiate {
             contracts,
             interactive,
+            coins,
             dry_run,
-        } => instantiate(settings, contracts, *interactive, *dry_run).await?,
+        } => instantiate(settings, contracts, *interactive, *coins, *dry_run).await?,
         Commands::Migrate {
             contracts,
             interactive,
@@ -116,6 +119,11 @@ where
             cw20_query(*dry_run).await?;
         }
         Commands::Cw20Instantiate { dry_run } => cw20_instantiate(*dry_run).await?,
+        Commands::Cw20Transfer {
+            recipient,
+            contract_addr,
+            amount,
+        } => cw20_transfer(recipient.clone(), contract_addr.clone(), *amount).await?,
         Commands::ExecutePayload { address, payload } => custom_execute(address, payload).await?,
         Commands::QueryPayload { address, payload } => custom_query(address, payload).await?,
         Commands::SetConfig { contracts, dry_run } => {
@@ -261,7 +269,7 @@ pub async fn deploy(
         build(settings, contracts, cargo_args).await?;
     }
     store_code(settings, contracts, dry_run).await?;
-    instantiate(settings, contracts, dry_run, false).await?;
+    instantiate(settings, contracts, false, false, dry_run).await?;
     set_config(settings, contracts, dry_run).await?;
     set_up(settings, contracts, dry_run).await?;
     Ok(())
@@ -582,7 +590,7 @@ pub async fn store_code(
     let chunk_size = CONFIG.read().await.settings.store_code_chunk_size;
     let chunks = contracts.chunks(chunk_size);
     for chunk in chunks {
-        execute_deployment(settings, chunk, dry_run, DeploymentStage::StoreCode).await?;
+        execute_deployment(settings, chunk, false, dry_run, DeploymentStage::StoreCode).await?;
     }
     Ok(())
 }
@@ -591,18 +599,21 @@ pub async fn instantiate(
     settings: &WorkspaceSettings,
     contracts: &[impl Deploy],
     interactive: bool,
+    coins: bool,
     dry_run: bool,
 ) -> anyhow::Result<()> {
     execute_deployment(
         settings,
         contracts,
+        coins,
         dry_run,
         DeploymentStage::Instantiate { interactive },
     )
     .await?;
     execute_deployment(
         settings,
         contracts,
+        coins,
         dry_run,
         DeploymentStage::ExternalInstantiate,
     )
@@ -627,6 +638,7 @@ pub async fn migrate(
     execute_deployment(
         settings,
         contracts,
+        false,
         dry_run,
         DeploymentStage::Migrate { interactive },
     )
@@ -640,7 +652,14 @@ pub async fn set_config(
     contracts: &[impl Deploy],
     dry_run: bool,
 ) -> anyhow::Result<()> {
-    execute_deployment(settings, contracts, dry_run, DeploymentStage::SetConfig).await?;
+    execute_deployment(
+        settings,
+        contracts,
+        false,
+        dry_run,
+        DeploymentStage::SetConfig,
+    )
+    .await?;
     Ok(())
 }
 
@@ -649,7 +668,7 @@ pub async fn set_up(
     contracts: &[impl Deploy],
     dry_run: bool,
 ) -> anyhow::Result<()> {
-    execute_deployment(settings, contracts, dry_run, DeploymentStage::SetUp).await?;
+    execute_deployment(settings, contracts, false, dry_run, DeploymentStage::SetUp).await?;
     Ok(())
 }
 

wasm-deploy/src/config/config.rs

@@ -3,11 +3,13 @@ use crate::config::{WorkspaceSettings, WORKSPACE_SETTINGS};
 use crate::error::DeployError;
 #[cfg(feature = "ledger")]
 use crate::ledger::get_ledger_info;
+use cosm_utils::cosmrs;
 use cosm_utils::prelude::*;
 use cosm_utils::{
     config::cfg::ChainConfig,
     signing_key::key::{Key, KeyringParams, UserKey},
 };
+use cosmrs::rpc::HttpClient;
 use futures::executor::block_on;
 use ibc_chain_registry::{chain::ChainData, constants::ALL_CHAINS, fetchable::Fetchable};
 use inquire::{Confirm, CustomType, Select, Text};
@@ -24,7 +26,6 @@ use std::{
     path::PathBuf,
     sync::Arc,
 };
-use tendermint_rpc::HttpClient;
 use tokio::sync::RwLock;
 
 use super::{ContractInfo, Env, UserSettings};

wasm-deploy/src/cw20.rs

@@ -3,6 +3,7 @@ use std::str::FromStr;
 use crate::{config::CONFIG, contract::Deploy};
 use colored::Colorize;
 use colored_json::to_colored_json_auto;
+use cosm_utils::cosmrs;
 use cosm_utils::prelude::*;
 use cosm_utils::{
     chain::{coin::Coin, request::TxOptions},
@@ -11,10 +12,10 @@ use cosm_utils::{
         cosmwasm::model::{ExecRequest, InstantiateRequest},
     },
 };
+use cosmrs::rpc::HttpClient;
 use cw20::Cw20ExecuteMsg;
 use inquire::{CustomType, Text};
 use interactive_parse::InteractiveParseObj;
-use tendermint_rpc::HttpClient;
 
 pub async fn cw20_send(contract: &impl Deploy, dry_run: bool) -> anyhow::Result<()> {
     println!("Executing cw20 send");
@@ -138,3 +139,36 @@ pub async fn cw20_instantiate(dry_run: bool) -> anyhow::Result<()> {
     }
     Ok(())
 }
+
+pub async fn cw20_transfer(
+    recipient: String,
+    contract_addr: String,
+    amount: u128,
+) -> anyhow::Result<()> {
+    println!("Executing cw20 transfer");
+    let config = CONFIG.read().await;
+    let key = config.get_active_key().await?;
+    let msg = Cw20ExecuteMsg::Transfer {
+        recipient,
+        amount: amount.into(),
+    };
+    let chain_info = config.get_active_chain_info()?.clone();
+    let client = HttpClient::get_persistent_compat(chain_info.rpc_endpoint.as_str()).await?;
+    let funds = Vec::<Coin>::parse_to_obj()?;
+    let req = ExecRequest {
+        msg,
+        funds,
+        address: Address::from_str(&contract_addr)?,
+    };
+
+    let response = client
+        .wasm_execute_commit(&chain_info.cfg, req, &key, &TxOptions::default())
+        .await?;
+    println!(
+        "gas wanted: {}, gas used: {}",
+        response.tx_result.gas_wanted.to_string().green(),
+        response.tx_result.gas_used.to_string().green()
+    );
+    println!("tx hash: {}", response.hash.to_string().purple());
+    Ok(())
+}

wasm-deploy/src/deployment.rs

@@ -1,7 +1,7 @@
-use std::str::FromStr;
-
 use colored::Colorize;
 use colored_json::to_colored_json_auto;
+use cosm_utils::chain::coin::Coin;
+use cosm_utils::cosmrs;
 use cosm_utils::{
     chain::request::TxOptions,
     modules::{
@@ -11,8 +11,10 @@ use cosm_utils::{
     prelude::*,
     signing_key::key::UserKey,
 };
+use cosmrs::rpc::{endpoint::broadcast::tx_commit, HttpClient};
+use interactive_parse::InteractiveParseObj;
 use log::debug;
-use tendermint_rpc::{endpoint::broadcast::tx_commit, HttpClient};
+use std::str::FromStr;
 
 use crate::{
     config::{ChainInfo, ContractInfo, WorkspaceSettings, CONFIG},
@@ -33,6 +35,7 @@ pub enum DeploymentStage {
 pub async fn execute_deployment(
     settings: &WorkspaceSettings,
     contracts: &[impl Deploy],
+    coins: bool,
     dry_run: bool,
     deployment_stage: DeploymentStage,
 ) -> anyhow::Result<()> {
@@ -51,6 +54,7 @@ pub async fn execute_deployment(
             execute_instantiate(
                 contracts,
                 interactive,
+                coins,
                 dry_run,
                 &client,
                 &chain_info,
@@ -286,6 +290,7 @@ async fn execute_external_instantiate(
 async fn execute_instantiate(
     contracts: &[impl Deploy],
     interactive: bool,
+    coins: bool,
     dry_run: bool,
     client: &HttpClient,
     chain_info: &ChainInfo,
@@ -318,6 +323,9 @@ async fn execute_instantiate(
             );
             let contract_info = config.get_contract(&contract.to_string())?;
             let code_id = contract_info.code_id.ok_or(DeployError::CodeIdNotFound)?;
+            if coins {
+                Coin::parse_to_obj()?;
+            }
             reqs.push(InstantiateRequest {
                 code_id,
                 msg,

wasm-deploy/src/execute.rs

@@ -4,16 +4,17 @@ use crate::{
 };
 use colored::Colorize;
 use colored_json::to_colored_json_auto;
+use cosm_utils::cosmrs;
 use cosm_utils::{
     chain::{coin::Coin, request::TxOptions},
     modules::{auth::model::Address, cosmwasm::model::ExecRequest},
     prelude::*,
 };
+use cosmrs::rpc::HttpClient;
 use interactive_parse::InteractiveParseObj;
 use log::debug;
 use serde::Serialize;
 use std::{fmt::Debug, str::FromStr};
-use tendermint_rpc::HttpClient;
 
 pub async fn execute_contract(contract: &impl Deploy, dry_run: bool) -> anyhow::Result<()> {
     println!("Executing");

wasm-deploy/src/query.rs

@@ -1,14 +1,15 @@
 use std::{fmt::Debug, str::FromStr};
 
 use colored_json::to_colored_json_auto;
+use cosm_utils::cosmrs;
 use cosm_utils::{modules::auth::model::Address, prelude::*};
+use cosmrs::rpc::HttpClient;
 use cw20::Cw20QueryMsg;
 use inquire::Text;
 use interactive_parse::InteractiveParseObj;
 use log::debug;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_json::Value;
-use tendermint_rpc::HttpClient;
 
 use crate::{
     config::{Config, CONFIG},

wasm-deploy/src/utils.rs

@@ -3,12 +3,13 @@ use crate::{
     error::DeployError,
 };
 use colored::Colorize;
+use cosm_utils::cosmrs;
+use cosmrs::rpc::endpoint::broadcast::tx_commit;
 use futures::executor::block_on;
 use lazy_static::lazy_static;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_json::Value;
 use std::sync::Arc;
-use tendermint_rpc::endpoint::broadcast::tx_commit;
 
 lazy_static! {
     pub static ref BIN_NAME: String = std::env::current_exe()