cosm-orc 1.0.0

Cosmwasm smart contract orchestration and gas profiling library
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

use cosmrs::{
    tendermint::abci::{Code, Log},
    ErrorReport,
};
use prost::{DecodeError, EncodeError};
use tendermint_rpc::endpoint::{abci_query::AbciQuery, broadcast::tx_commit::TxResult};
use thiserror::Error;

#[derive(Error, Debug)]
pub enum ClientError {
    #[error("malformed rpc url")]
    InvalidURL { source: tendermint_rpc::Error },

    #[error("invalid account ID: {id:?}")]
    AccountId { id: String },

    #[error("cryptographic error")]
    Crypto { source: ErrorReport },

    #[error("invalid denomination: {name:?}")]
    Denom { name: String },

    #[error("invalid chainId: {chain_id:?}")]
    ChainId { chain_id: String },

    #[error("invalid mnemonic")]
    Mnemonic,

    #[error("invalid derivation path")]
    DerviationPath,

    #[error("proto encoding error")]
    ProtoEncoding { source: ErrorReport },

    #[error("proto decoding error")]
    ProtoDecoding { source: ErrorReport },

    #[error("CosmosSDK error")]
    CosmosSdk { res: TendermintRes },

    #[error(transparent)]
    RPC(#[from] tendermint_rpc::Error),
}

impl ClientError {
    pub fn crypto(e: ErrorReport) -> ClientError {
        ClientError::Crypto { source: e }
    }

    pub fn proto_encoding(e: ErrorReport) -> ClientError {
        ClientError::ProtoEncoding { source: e }
    }

    pub fn prost_proto_en(e: EncodeError) -> ClientError {
        ClientError::ProtoEncoding { source: e.into() }
    }

    pub fn prost_proto_de(e: DecodeError) -> ClientError {
        ClientError::ProtoDecoding { source: e.into() }
    }
}

#[derive(Debug)]
pub struct TendermintRes {
    pub code: Code,
    pub log: Log,
}

impl From<TxResult> for TendermintRes {
    fn from(res: TxResult) -> TendermintRes {
        TendermintRes {
            code: res.code,
            log: res.log,
        }
    }
}

impl From<AbciQuery> for TendermintRes {
    fn from(res: AbciQuery) -> TendermintRes {
        TendermintRes {
            code: res.code,
            log: res.log,
        }
    }
}