cw-orch-daemon 0.28.0

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

use crate::{cosmos_modules, error::DaemonError, Daemon};
use cosmrs::proto::cosmos::base::query::v1beta1::PageRequest;
use cosmwasm_std::Addr;
use cw_orch_core::environment::{Querier, QuerierGetter};
use tokio::runtime::Handle;
use tonic::transport::Channel;

/// Queries for Cosmos AuthZ Module
/// All the async function are prefixed with `_`
pub struct Authz {
    pub channel: Channel,
    pub rt_handle: Option<Handle>,
}

impl Authz {
    pub fn new(daemon: &Daemon) -> Self {
        Self {
            channel: daemon.channel(),
            rt_handle: Some(daemon.rt_handle.clone()),
        }
    }

    pub fn new_async(channel: Channel) -> Self {
        Self {
            channel,
            rt_handle: None,
        }
    }
}

impl Querier for Authz {
    type Error = DaemonError;
}

impl QuerierGetter<Authz> for Daemon {
    fn querier(&self) -> Authz {
        Authz::new(self)
    }
}

impl Authz {
    /// Query Authz Grants from grantee to granter
    pub async fn _grants(
        &self,
        granter: &Addr,
        grantee: &Addr,
        msg_type_url: String,
        pagination: Option<PageRequest>,
    ) -> Result<cosmrs::proto::cosmos::authz::v1beta1::QueryGrantsResponse, DaemonError> {
        use cosmos_modules::authz::{query_client::QueryClient, QueryGrantsRequest};
        let mut client: QueryClient<Channel> = QueryClient::new(self.channel.clone());
        let grants = client
            .grants(QueryGrantsRequest {
                granter: granter.to_string(),
                grantee: grantee.to_string(),
                msg_type_url,
                pagination,
            })
            .await?
            .into_inner();
        Ok(grants)
    }

    /// Query Authz Grants of grantee
    pub async fn _grantee_grants(
        &self,
        grantee: &Addr,
        pagination: Option<PageRequest>,
    ) -> Result<cosmrs::proto::cosmos::authz::v1beta1::QueryGranteeGrantsResponse, DaemonError>
    {
        use cosmos_modules::authz::{query_client::QueryClient, QueryGranteeGrantsRequest};
        let mut client: QueryClient<Channel> = QueryClient::new(self.channel.clone());
        let grants = client
            .grantee_grants(QueryGranteeGrantsRequest {
                grantee: grantee.to_string(),
                pagination,
            })
            .await?
            .into_inner();
        Ok(grants)
    }

    /// Query Authz Grants for granter
    pub async fn _granter_grants(
        &self,
        granter: &Addr,
        pagination: Option<PageRequest>,
    ) -> Result<cosmrs::proto::cosmos::authz::v1beta1::QueryGranterGrantsResponse, DaemonError>
    {
        use cosmos_modules::authz::{query_client::QueryClient, QueryGranterGrantsRequest};
        let mut client: QueryClient<Channel> = QueryClient::new(self.channel.clone());
        let grants = client
            .granter_grants(QueryGranterGrantsRequest {
                granter: granter.to_string(),
                pagination,
            })
            .await?
            .into_inner();
        Ok(grants)
    }
}