cosmrs 0.22.0

Transaction builder and signer for Cosmos-based blockchains
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

use crate::{
    proto::{self, traits::ParseOptional},
    tx::Msg,
    AccountId, Coin, ErrorReport, Result,
};

/// MsgInstantiateContract create a new smart contract instance for the given
/// code id.
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
pub struct MsgInstantiateContract {
    /// Sender is the that actor that signed the messages
    pub sender: AccountId,

    /// Admin is an optional address that can execute migrations
    pub admin: Option<AccountId>,

    /// CodeID is the reference to the stored WASM code
    pub code_id: u64,

    /// Label is optional metadata to be stored with a contract instance.
    pub label: Option<String>,

    /// Msg json encoded message to be passed to the contract on instantiation
    pub msg: Vec<u8>,

    /// Funds coins that are transferred to the contract on instantiation
    pub funds: Vec<Coin>,
}

impl Msg for MsgInstantiateContract {
    type Proto = proto::cosmwasm::wasm::v1::MsgInstantiateContract;
}

impl TryFrom<proto::cosmwasm::wasm::v1::MsgInstantiateContract> for MsgInstantiateContract {
    type Error = ErrorReport;

    fn try_from(
        proto: proto::cosmwasm::wasm::v1::MsgInstantiateContract,
    ) -> Result<MsgInstantiateContract> {
        Ok(MsgInstantiateContract {
            sender: proto.sender.parse()?,
            admin: proto.admin.parse_optional()?,
            code_id: proto.code_id,
            label: proto.label.parse_optional()?,
            msg: proto.msg,
            funds: proto
                .funds
                .into_iter()
                .map(TryFrom::try_from)
                .collect::<Result<_, _>>()?,
        })
    }
}

impl From<MsgInstantiateContract> for proto::cosmwasm::wasm::v1::MsgInstantiateContract {
    fn from(msg: MsgInstantiateContract) -> proto::cosmwasm::wasm::v1::MsgInstantiateContract {
        proto::cosmwasm::wasm::v1::MsgInstantiateContract {
            sender: msg.sender.to_string(),
            admin: msg.admin.map(|admin| admin.to_string()).unwrap_or_default(),
            code_id: msg.code_id,
            label: msg.label.unwrap_or_default(),
            msg: msg.msg,
            funds: msg.funds.into_iter().map(Into::into).collect(),
        }
    }
}

/// MsgInstantiateContractResponse return instantiation result data
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
pub struct MsgInstantiateContractResponse {
    /// Address is the bech32 address of the new contract instance.
    pub address: AccountId,

    /// Data contains base64-encoded bytes to returned from the contract
    pub data: Vec<u8>,
}

impl Msg for MsgInstantiateContractResponse {
    type Proto = proto::cosmwasm::wasm::v1::MsgInstantiateContractResponse;
}

impl TryFrom<proto::cosmwasm::wasm::v1::MsgInstantiateContractResponse>
    for MsgInstantiateContractResponse
{
    type Error = ErrorReport;

    fn try_from(
        proto: proto::cosmwasm::wasm::v1::MsgInstantiateContractResponse,
    ) -> Result<MsgInstantiateContractResponse> {
        Ok(MsgInstantiateContractResponse {
            address: proto.address.parse()?,
            data: proto.data,
        })
    }
}

impl From<MsgInstantiateContractResponse>
    for proto::cosmwasm::wasm::v1::MsgInstantiateContractResponse
{
    fn from(
        msg: MsgInstantiateContractResponse,
    ) -> proto::cosmwasm::wasm::v1::MsgInstantiateContractResponse {
        proto::cosmwasm::wasm::v1::MsgInstantiateContractResponse {
            address: msg.address.to_string(),
            data: msg.data,
        }
    }
}