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
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

//! Mode info.

use super::SignMode;
use crate::{crypto::CompactBitArray, proto, Error, ErrorReport, Result};

/// [`ModeInfo`] describes the signing mode of a single or nested multisig signer.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ModeInfo {
    /// Single represents a single signer.
    Single(Single),

    /// Multi represents a nested multisig signer.
    Multi(Multi),
}

impl ModeInfo {
    /// Create [`ModeInfo`] for a single signer using the given mode.
    pub fn single(sign_mode: SignMode) -> ModeInfo {
        ModeInfo::Single(sign_mode.into())
    }
}

impl TryFrom<proto::cosmos::tx::v1beta1::ModeInfo> for ModeInfo {
    type Error = ErrorReport;

    fn try_from(proto: proto::cosmos::tx::v1beta1::ModeInfo) -> Result<ModeInfo> {
        match proto.sum {
            Some(proto::cosmos::tx::v1beta1::mode_info::Sum::Single(single)) => {
                Ok(ModeInfo::Single(single.into()))
            }
            Some(proto::cosmos::tx::v1beta1::mode_info::Sum::Multi(multi)) => {
                Ok(ModeInfo::Multi(multi.try_into()?))
            }
            None => Err(Error::MissingField { name: "mode_info" }.into()),
        }
    }
}

impl From<ModeInfo> for proto::cosmos::tx::v1beta1::ModeInfo {
    fn from(mode_info: ModeInfo) -> proto::cosmos::tx::v1beta1::ModeInfo {
        proto::cosmos::tx::v1beta1::ModeInfo {
            sum: Some(match mode_info {
                ModeInfo::Single(single) => {
                    proto::cosmos::tx::v1beta1::mode_info::Sum::Single(single.into())
                }
                ModeInfo::Multi(multi) => {
                    proto::cosmos::tx::v1beta1::mode_info::Sum::Multi(multi.into())
                }
            }),
        }
    }
}

impl From<Single> for ModeInfo {
    fn from(single: Single) -> ModeInfo {
        ModeInfo::Single(single)
    }
}

impl From<Multi> for ModeInfo {
    fn from(multi: Multi) -> ModeInfo {
        ModeInfo::Multi(multi)
    }
}

/// [`Single`] is the mode info for a single signer.
///
/// It is structured as a message to allow for additional fields such as locale for
/// `SIGN_MODE_TEXTUAL` in the future.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct Single {
    /// Signing mode of the single signer.
    pub mode: SignMode,
}

impl From<proto::cosmos::tx::v1beta1::mode_info::Single> for Single {
    fn from(proto: proto::cosmos::tx::v1beta1::mode_info::Single) -> Single {
        Single { mode: proto.mode() }
    }
}

impl From<Single> for proto::cosmos::tx::v1beta1::mode_info::Single {
    fn from(single: Single) -> proto::cosmos::tx::v1beta1::mode_info::Single {
        proto::cosmos::tx::v1beta1::mode_info::Single {
            mode: single.mode as _,
        }
    }
}

impl From<SignMode> for Single {
    fn from(mode: SignMode) -> Single {
        Single { mode }
    }
}

impl From<Single> for SignMode {
    fn from(single: Single) -> SignMode {
        single.mode
    }
}

/// [`Multi`] is the mode info for a multisig public key.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Multi {
    /// Specifies which keys within the multisig are signing.
    pub bitarray: CompactBitArray,

    /// Corresponding modes of the signers of the multisig which could include nested
    /// multisig public keys.
    pub mode_infos: Vec<ModeInfo>,
}

impl TryFrom<proto::cosmos::tx::v1beta1::mode_info::Multi> for Multi {
    type Error = ErrorReport;

    fn try_from(proto: proto::cosmos::tx::v1beta1::mode_info::Multi) -> Result<Multi> {
        Ok(Multi {
            bitarray: proto
                .bitarray
                .map(Into::into)
                .ok_or(Error::MissingField { name: "bitarray" })?,
            mode_infos: proto
                .mode_infos
                .into_iter()
                .map(TryInto::try_into)
                .collect::<Result<_, _>>()?,
        })
    }
}

impl From<Multi> for proto::cosmos::tx::v1beta1::mode_info::Multi {
    fn from(multi: Multi) -> proto::cosmos::tx::v1beta1::mode_info::Multi {
        proto::cosmos::tx::v1beta1::mode_info::Multi {
            bitarray: Some(multi.bitarray.into()),
            mode_infos: multi.mode_infos.into_iter().map(Into::into).collect(),
        }
    }
}