beaker 0.1.3

CosmWasm swiss-army knife configured for Osmosis by default, but trivial to make it work for other CosmWasm enabled chain.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use clap::Subcommand;
use std::path::PathBuf;

use crate::{
    framework::Context,
    modules::wasm::{args::BaseTxArgs, WasmConfig},
    support::gas::Gas,
};

use super::proposal_struct::StoreCodeProposal;

#[derive(Subcommand, Debug)]
pub enum ProposalCmd {
    /// Proposal for storing .wasm on chain for later initialization
    StoreCode {
        /// Name of the contract to store
        contract_name: String,

        /// Restricting the code to be able to instantiate/migrate only by given address, no restriction by default
        #[clap(long)]
        permit_instantiate_only: Option<String>,

        /// Path to proposal file, could be either yaml / toml format.
        #[clap(short, long)]
        proposal: Option<PathBuf>,

        #[clap(flatten)]
        store_code_proposal: StoreCodeProposal,

        #[clap(flatten)]
        base_tx_args: BaseTxArgs,
    },
    /// Vote for proposal
    Vote {
        /// Name of the contract to store
        contract_name: String,

        /// Vote option, one of: yes, no, no_with_veto, abstain
        #[clap(short, long)]
        option: String,

        #[clap(flatten)]
        base_tx_args: BaseTxArgs,
    },
    Query {
        #[clap(subcommand)]
        cmd: ProposalQueryCmd,
    },
}

#[derive(Subcommand, Debug)]
pub enum ProposalQueryCmd {
    /// Proposal for storing .wasm on chain for later initialization
    StoreCode {
        /// Name of the contract to store
        contract_name: String,

        #[clap(short, long, default_value = "local")]
        network: String,
    },
}

pub fn execute<'a, Ctx: Context<'a, WasmConfig>>(
    ctx: Ctx,
    cmd: &ProposalCmd,
) -> Result<(), anyhow::Error> {
    match cmd {
        ProposalCmd::StoreCode {
            contract_name,
            permit_instantiate_only,
            proposal,
            store_code_proposal,
            base_tx_args,
        } => {
            let proposal = if let Some(p) = proposal {
                let proposal_str = std::fs::read_to_string(p)?;
                let extention_error_msg = "Extension must be one of `yaml`, `yml` or `toml`";
                let ext = p.extension().expect(extention_error_msg);
                let store_code_proposal: StoreCodeProposal = if ext == "yaml" || ext == "yml" {
                    serde_yaml::from_str(proposal_str.as_str())?
                } else if ext == "toml" {
                    toml::from_str(proposal_str.as_str())?
                } else {
                    panic!("{}", extention_error_msg);
                };
                Some(store_code_proposal)
            } else {
                None
            };

            let store_code_proposal @ StoreCodeProposal { title, deposit, .. } =
                proposal.as_ref().unwrap_or(store_code_proposal);

            let BaseTxArgs {
                network,
                signer_args,
                gas_args,
                timeout_height,
            }: &BaseTxArgs = base_tx_args;

            super::ops::propose_store_code(
                &ctx,
                contract_name,
                title.as_str(),
                store_code_proposal.description_with_metadata()?.as_str(),
                deposit.as_ref().map(|s| s.as_str()).try_into()?,
                network,
                {
                    let global_conf = ctx.global_config()?;
                    &Gas::from_args(
                        gas_args,
                        global_conf.gas_price(),
                        global_conf.gas_adjustment(),
                    )?
                },
                permit_instantiate_only,
                timeout_height,
                signer_args.private_key(&ctx.global_config()?)?,
            )?;
            Ok(())
        }
        ProposalCmd::Query { cmd } => match cmd {
            ProposalQueryCmd::StoreCode {
                contract_name,
                network,
            } => {
                super::ops::query_proposal(&ctx, contract_name, network)?;
                Ok(())
            }
        },
        ProposalCmd::Vote {
            contract_name,
            option,
            base_tx_args,
        } => {
            let BaseTxArgs {
                network,
                signer_args,
                gas_args,
                timeout_height,
            }: &BaseTxArgs = base_tx_args;

            super::ops::vote(
                &ctx,
                contract_name,
                option,
                network,
                {
                    let global_conf = ctx.global_config()?;
                    &Gas::from_args(
                        gas_args,
                        global_conf.gas_price(),
                        global_conf.gas_adjustment(),
                    )?
                },
                timeout_height,
                signer_args.private_key(&ctx.global_config()?)?,
            )?;
            Ok(())
        }
    }
}