Merge pull request #103 from vernonjohnson/vt-execute-and-query

Author: iboss-ptk

README.md

@@ -290,6 +290,20 @@ beaker wasm upgrade counter --signer-account test1 --no-wasm-opt
 
 You can find more information about their options [here](./docs/commands/beaker_wasm.md).
 
+### Execute Contract Messages
+
+Contract messages can be executed using the `beaker wasm execute` subcommand. For example:
+```sh
+beaker wasm execute counter --raw '{ "increment": {} }' --signer-account test1
+```
+
+### Query Contract State
+You can query contract state by submitting query messages with the `beaker wasm query` command. For example:
+```sh
+beaker wasm query counter --raw '{"get_count": {}}'
+```
+
+
 ### Signers
 
 Whenever you run command that requires signing transactions, there are 3 options you can reference your private keys:

packages/cli/Cargo.toml

@@ -28,6 +28,7 @@ serde = "1.0.137"
 serde_json = "1.0.81"
 serde_yaml = "0.8"
 tendermint-rpc = "0.23.7"
+textwrap = "0.15.0"
 tokio = {version = "1.18.2", features = ["full"]}
 toml = "0.5.9"
 

packages/cli/src/modules/wasm/entrypoint.rs

@@ -252,6 +252,35 @@ pub enum WasmCmd {
         #[clap(subcommand)]
         cmd: ProposalCmd,
     },
+    /// Execute contract messages
+    Execute {
+        contract_name: String,
+
+        #[clap(short, long, default_value = "default")]
+        label: String,
+
+        #[clap(short, long)]
+        raw: Option<String>,
+
+        #[clap(short, long)]
+        funds: Option<String>,
+
+        #[clap(flatten)]
+        base_tx_args: BaseTxArgs,
+    },
+    /// Query contract state
+    Query {
+        contract_name: String,
+
+        #[clap(short, long, default_value = "default")]
+        label: String,
+
+        #[clap(short, long)]
+        raw: Option<String>,
+
+        #[clap(flatten)]
+        base_tx_args: BaseTxArgs,
+    },
 }
 
 #[derive(new)]
@@ -607,6 +636,49 @@ impl<'a> Module<'a, WasmConfig, WasmCmd, anyhow::Error> for WasmModule {
                 run_command(node_pkg().arg("run").arg("build"))?;
                 Ok(())
             }
+            WasmCmd::Execute {
+                contract_name,
+                label,
+                raw,
+                funds,
+                base_tx_args,
+            } => {
+                let BaseTxArgs {
+                    network,
+                    signer_args,
+                    gas_args,
+                    timeout_height,
+                }: &BaseTxArgs = base_tx_args;
+                ops::execute(
+                    &ctx,
+                    contract_name,
+                    label.as_str(),
+                    raw.as_ref(),
+                    funds.as_ref().map(|s| s.as_str()).try_into()?,
+                    network,
+                    timeout_height,
+                    {
+                        let global_conf = ctx.global_config()?;
+                        &Gas::from_args(
+                            gas_args,
+                            global_conf.gas_price(),
+                            global_conf.gas_adjustment(),
+                        )?
+                    },
+                    signer_args.private_key(&ctx.global_config()?)?,
+                )?;
+                Ok(())
+            }
+            WasmCmd::Query {
+                contract_name,
+                label,
+                raw,
+                base_tx_args,
+            } => {
+                let BaseTxArgs { network, .. }: &BaseTxArgs = base_tx_args;
+                ops::query(&ctx, contract_name, label.as_str(), raw.as_ref(), network)?;
+                Ok(())
+            }
         }
     }
 }

packages/cli/src/modules/wasm/ops/execute.rs

@@ -0,0 +1,108 @@
+use crate::attrs_format;
+use crate::modules::wasm::config::WasmConfig;
+use crate::support::coin::Coins;
+use crate::support::cosmos::ResponseValuePicker;
+use crate::support::future::block;
+use crate::support::gas::Gas;
+use crate::support::ops_response::OpResponseDisplay;
+use crate::support::state::State;
+use crate::{framework::Context, support::cosmos::Client};
+use anyhow::anyhow;
+use anyhow::Context as _;
+use anyhow::Result;
+use cosmrs::cosmwasm::MsgExecuteContract;
+use cosmrs::crypto::secp256k1::SigningKey;
+use cosmrs::tx::Msg;
+use cosmrs::AccountId;
+
+use std::{fs, vec};
+
+#[allow(clippy::too_many_arguments)]
+pub fn execute<'a, Ctx: Context<'a, WasmConfig>>(
+    ctx: &Ctx,
+    contract_name: &str,
+    label: &str,
+    raw: Option<&String>,
+    funds: Coins,
+    network: &str,
+    timeout_height: &u32,
+    gas: &Gas,
+    signing_key: SigningKey,
+) -> Result<ExecuteResponse> {
+    let global_config = ctx.global_config()?;
+    let account_prefix = global_config.account_prefix().as_str();
+
+    let network_info = global_config
+        .networks()
+        .get(network)
+        .with_context(|| format!("Unable to find network config: {network}"))?
+        .to_owned();
+
+    let client = Client::new(network_info.clone()).to_signing_client(signing_key, account_prefix);
+    let state = State::load_by_network(network_info, ctx.root()?)?;
+
+    let contract = state
+        .get_ref(network, contract_name)?
+        .addresses()
+        .get(label)
+        .with_context(|| format!("Unable to retrieve contract for {contract_name}:{label}"))?
+        .parse::<AccountId>()
+        .map_err(|e| anyhow!(e))?;
+
+    let msg_instantiate_contract = MsgExecuteContract {
+        sender: client.signer_account_id(),
+        contract,
+        msg: raw
+            .map(|s| s.as_bytes().to_vec())
+            .map(Ok)
+            .unwrap_or_else(|| {
+                let path = ctx
+                    .root()?
+                    .join("contracts")
+                    .join(contract_name)
+                    .join("execute-msgs")
+                    .join(format!("{label}.json"));
+                fs::read_to_string(&path)
+                    .with_context(|| format!("Unable to execute with `{}`", path.to_string_lossy()))
+                    .map(|s| s.as_bytes().to_vec())
+            })?,
+        funds: funds.into(),
+    };
+
+    block(async {
+        let response = client
+            .sign_and_broadcast(
+                vec![msg_instantiate_contract.to_any().unwrap()],
+                gas,
+                "",
+                timeout_height,
+            )
+            .await?;
+
+        let contract_address = response.pick("execute", "_contract_address").to_string();
+
+        let execute_response = ExecuteResponse {
+            contract_address,
+            label: label.to_string(),
+        };
+
+        execute_response.log();
+
+        Ok(execute_response)
+    })
+}
+
+#[allow(dead_code)]
+pub struct ExecuteResponse {
+    pub label: String,
+    pub contract_address: String,
+}
+
+impl OpResponseDisplay for ExecuteResponse {
+    fn headline() -> &'static str {
+        "Contract executed successfully!! 🎉 "
+    }
+    fn attrs(&self) -> Vec<String> {
+        attrs_format! { self | label, contract_address }
+    }
+}

packages/cli/src/modules/wasm/ops/mod.rs

@@ -1,19 +1,23 @@
 pub mod build;
 pub mod clear_admin;
 pub mod deploy;
+pub mod execute;
 pub mod instantiate;
 pub mod migrate;
 pub mod new;
+pub mod query;
 pub mod store_code;
 pub mod update_admin;
 pub mod upgrade;
 
 pub use build::build;
 pub use clear_admin::clear_admin;
 pub use deploy::deploy;
+pub use execute::execute;
 pub use instantiate::instantiate;
 pub use migrate::migrate;
 pub use new::new;
+pub use query::query;
 pub use store_code::store_code;
 pub use update_admin::update_admin;
 pub use upgrade::upgrade;

packages/cli/src/modules/wasm/ops/query.rs

@@ -0,0 +1,88 @@
+use crate::attrs_format;
+use crate::modules::wasm::config::WasmConfig;
+use crate::support::future::block;
+use crate::support::ops_response::OpResponseDisplay;
+use crate::support::state::State;
+use crate::{framework::Context, support::cosmos::Client};
+use anyhow::anyhow;
+use anyhow::Context as _;
+use anyhow::Result;
+use cosmrs::AccountId;
+
+use std::fs;
+
+#[allow(clippy::too_many_arguments)]
+pub fn query<'a, Ctx: Context<'a, WasmConfig>>(
+    ctx: &Ctx,
+    contract_name: &str,
+    label: &str,
+    raw: Option<&String>,
+    network: &str,
+) -> Result<QueryResponse> {
+    let global_config = ctx.global_config()?;
+    let network_info = global_config
+        .networks()
+        .get(network)
+        .with_context(|| format!("Unable to find network config: {network}"))?
+        .to_owned();
+
+    let client = Client::new(network_info.clone());
+    let state = State::load_by_network(network_info, ctx.root()?)?;
+
+    let contract = state
+        .get_ref(network, contract_name)?
+        .addresses()
+        .get(label)
+        .with_context(|| format!("Unable to retrieve contract for {contract_name}:{label}"))?
+        .parse::<AccountId>()
+        .map_err(|e| anyhow!(e))?;
+
+    let query_msg = raw
+        .map(|s| s.as_bytes().to_vec())
+        .map(Ok)
+        .unwrap_or_else(|| {
+            let path = ctx
+                .root()?
+                .join("contracts")
+                .join(contract_name)
+                .join("query-msgs")
+                .join(format!("{label}.json"));
+            fs::read_to_string(&path)
+                .with_context(|| format!("Unable to execute with `{}`", path.to_string_lossy()))
+                .map(|s| s.as_bytes().to_vec())
+        })?;
+
+    block(async {
+        let response = client.query_smart(contract.to_string(), query_msg).await?;
+        let pretty_json_response = serde_json::to_string_pretty(
+            &serde_json::from_slice::<serde_json::Value>(&response)
+                .with_context(|| "Unable to deserialize response")?,
+        )?;
+
+        let query_response = QueryResponse {
+            label: label.to_string(),
+            contract_address: contract.to_string(),
+            data: format!("\n{}", textwrap::indent(&pretty_json_response, "        ")),
+        };
+
+        query_response.log();
+
+        Ok(query_response)
+    })
+}
+
+#[allow(dead_code)]
+pub struct QueryResponse {
+    pub label: String,
+    pub contract_address: String,
+    pub data: String,
+}
+
+impl OpResponseDisplay for QueryResponse {
+    fn headline() -> &'static str {
+        "Succesffuly executed query!! 🎉 "
+    }
+    fn attrs(&self) -> Vec<String> {
+        attrs_format! { self | label, contract_address, data }
+    }
+}

packages/cli/src/support/cosmos.rs

@@ -102,6 +102,26 @@ impl Client {
             .map_err(|e: cosmrs::ErrorReport| anyhow!(e))
     }
 
+    pub async fn query_smart(&self, address: String, query_data: Vec<u8>) -> Result<Vec<u8>> {
+        use cosmos_sdk_proto::cosmwasm::wasm::v1::*;
+        let grpc_endpoint = self.network.grpc_endpoint();
+
+        let mut c = query_client::QueryClient::connect(self.network.grpc_endpoint().clone())
+            .await
+            .context(format!("Unable to connect to {grpc_endpoint}"))?;
+
+        let res = c
+            .smart_contract_state(QuerySmartContractStateRequest {
+                address,
+                query_data,
+            })
+            .await?
+            .into_inner()
+            .data;
+
+        Ok(res)
+    }
+
     pub async fn proposal(&self, proposal_id: &u64) -> Result<Proposal> {
         use cosmos_sdk_proto::cosmos::gov::v1beta1::*;
         let grpc_endpoint = self.network.grpc_endpoint();