cw-orch-daemon 0.16.4

Scripting library for deploying and interacting with CosmWasm smart-contracts
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

use crate::{cosmos_modules, error::DaemonError};
use cosmrs::proto::cosmos::base::query::v1beta1::PageRequest;
use tonic::transport::Channel;

use super::DaemonQuerier;

/// Querier for the Cosmos Gov module
pub struct Gov {
    channel: Channel,
}

impl DaemonQuerier for Gov {
    fn new(channel: Channel) -> Self {
        Self { channel }
    }
}

impl Gov {
    /// Query proposal details by proposal id
    pub async fn proposal(
        &self,
        proposal_id: u64,
    ) -> Result<cosmos_modules::gov::Proposal, DaemonError> {
        let proposal: cosmos_modules::gov::QueryProposalResponse = cosmos_query!(
            self,
            gov,
            proposal,
            QueryProposalRequest {
                proposal_id: proposal_id,
            }
        );
        Ok(proposal.proposal.unwrap())
    }

    /// Query proposals based on given status
    ///
    /// see [PageRequest] for pagination
    pub async fn proposals(
        &self,
        proposal_status: GovProposalStatus,
        voter: impl Into<String>,
        depositor: impl Into<String>,
        pagination: Option<PageRequest>,
    ) -> Result<cosmos_modules::gov::QueryProposalsResponse, DaemonError> {
        let proposals: cosmos_modules::gov::QueryProposalsResponse = cosmos_query!(
            self,
            gov,
            proposals,
            QueryProposalsRequest {
                proposal_status: proposal_status as i32,
                voter: voter.into(),
                depositor: depositor.into(),
                pagination: pagination
            }
        );
        Ok(proposals)
    }

    /// Query voted information based on proposal_id for voter address
    pub async fn vote(
        &self,
        proposal_id: u64,
        voter: impl Into<String>,
    ) -> Result<cosmos_modules::gov::Vote, DaemonError> {
        let vote: cosmos_modules::gov::QueryVoteResponse = cosmos_query!(
            self,
            gov,
            vote,
            QueryVoteRequest {
                proposal_id: proposal_id,
                voter: voter.into()
            }
        );
        Ok(vote.vote.unwrap())
    }

    /// Query votes of a given proposal
    ///
    /// see [PageRequest] for pagination
    pub async fn votes(
        &self,
        proposal_id: impl Into<u64>,
        pagination: Option<PageRequest>,
    ) -> Result<cosmos_modules::gov::QueryVotesResponse, DaemonError> {
        let votes: cosmos_modules::gov::QueryVotesResponse = cosmos_query!(
            self,
            gov,
            votes,
            QueryVotesRequest {
                proposal_id: proposal_id.into(),
                pagination: pagination
            }
        );
        Ok(votes)
    }

    /// Query all parameters of the gov module
    pub async fn params(
        &self,
        params_type: impl Into<String>,
    ) -> Result<cosmos_modules::gov::QueryParamsResponse, DaemonError> {
        let params: cosmos_modules::gov::QueryParamsResponse = cosmos_query!(
            self,
            gov,
            params,
            QueryParamsRequest {
                params_type: params_type.into()
            }
        );
        Ok(params)
    }

    /// Query deposit information using proposal_id and depositor address
    pub async fn deposit(
        &self,
        proposal_id: u64,
        depositor: impl Into<String>,
    ) -> Result<cosmos_modules::gov::Deposit, DaemonError> {
        let deposit: cosmos_modules::gov::QueryDepositResponse = cosmos_query!(
            self,
            gov,
            deposit,
            QueryDepositRequest {
                proposal_id: proposal_id,
                depositor: depositor.into()
            }
        );
        Ok(deposit.deposit.unwrap())
    }

    /// Query deposits of a proposal
    ///
    /// see [PageRequest] for pagination
    pub async fn deposits(
        &self,
        proposal_id: u64,
        pagination: Option<PageRequest>,
    ) -> Result<cosmos_modules::gov::QueryDepositsResponse, DaemonError> {
        let deposits: cosmos_modules::gov::QueryDepositsResponse = cosmos_query!(
            self,
            gov,
            deposits,
            QueryDepositsRequest {
                proposal_id: proposal_id,
                pagination: pagination
            }
        );
        Ok(deposits)
    }

    /// TallyResult queries the tally of a proposal vote.
    pub async fn tally_result(
        &mut self,
        proposal_id: u64,
    ) -> Result<cosmos_modules::gov::TallyResult, DaemonError> {
        let tally_result: cosmos_modules::gov::QueryTallyResultResponse = cosmos_query!(
            self,
            gov,
            tally_result,
            QueryTallyResultRequest {
                proposal_id: proposal_id,
            }
        );
        Ok(tally_result.tally.unwrap())
    }
}

/// Proposal status
#[allow(missing_docs)]
pub enum GovProposalStatus {
    Unspecified = 0,
    DepositPeriod = 1,
    VotingPeriod = 2,
    Passed = 3,
    Rejected = 4,
    Failed = 5,
}