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

//! Signer info.

use super::{AuthInfo, Fee, ModeInfo, SequenceNumber, SignMode};
use crate::{
    crypto::{LegacyAminoMultisig, PublicKey},
    proto, Any, Error, ErrorReport, Result,
};
use eyre::WrapErr;

/// [`SignerInfo`] describes the public key and signing mode of a single top-level signer.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SignerInfo {
    /// [`PublicKey`] of the signer.
    ///
    /// It is optional for accounts that already exist in state. If unset, the verifier can use the
    /// required signer address for this position and lookup the public key.
    pub public_key: Option<SignerPublicKey>,

    /// Signing mode.
    ///
    /// Nested structure to support nested multisig [`PublicKey`]s.
    pub mode_info: ModeInfo,

    /// Sequence of the account, which describes the number of committed transactions signed by a
    /// given address.
    ///
    /// It is used to prevent replay attacks.
    pub sequence: SequenceNumber,
}

impl SignerInfo {
    /// Create [`SignerInfo`] for a single direct signer.
    pub fn single_direct(public_key: Option<PublicKey>, sequence: SequenceNumber) -> SignerInfo {
        SignerInfo {
            public_key: public_key.map(Into::into),
            mode_info: ModeInfo::single(SignMode::Direct),
            sequence,
        }
    }

    /// Get the [`AuthInfo`] for this signer with the given fee.
    ///
    /// This is primarily useful for cases involving a single signer.
    pub fn auth_info(self, fee: Fee) -> AuthInfo {
        AuthInfo {
            signer_infos: vec![self],
            fee,
        }
    }
}

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

    fn try_from(proto: proto::cosmos::tx::v1beta1::SignerInfo) -> Result<SignerInfo> {
        Ok(SignerInfo {
            public_key: proto.public_key.map(TryFrom::try_from).transpose()?,
            mode_info: proto
                .mode_info
                .ok_or(Error::MissingField { name: "mode_info" })?
                .try_into()?,
            sequence: proto.sequence,
        })
    }
}

impl From<SignerInfo> for proto::cosmos::tx::v1beta1::SignerInfo {
    fn from(signer_info: SignerInfo) -> proto::cosmos::tx::v1beta1::SignerInfo {
        proto::cosmos::tx::v1beta1::SignerInfo {
            public_key: signer_info.public_key.map(Into::into),
            mode_info: Some(signer_info.mode_info.into()),
            sequence: signer_info.sequence,
        }
    }
}

/// Signer's public key.
#[derive(Clone, Debug, PartialEq)]
pub enum SignerPublicKey {
    /// Single singer.
    Single(PublicKey),

    /// Legacy Amino multisig.
    LegacyAminoMultisig(LegacyAminoMultisig),

    /// Other key types beyond the ones provided above.
    Any(Any),
}

impl SignerPublicKey {
    /// Get the type URL for this [`SignerPublicKey`].
    pub fn type_url(&self) -> &str {
        match self {
            Self::Single(pk) => pk.type_url(),
            Self::LegacyAminoMultisig(_) => LegacyAminoMultisig::TYPE_URL,
            Self::Any(any) => &any.type_url,
        }
    }

    /// Get the [`PublicKey`] for a single signer, if applicable.
    pub fn single(&self) -> Option<&PublicKey> {
        match self {
            Self::Single(pk) => Some(pk),
            _ => None,
        }
    }

    /// Get the [`LegacyAminoMultisig`] key info, if applicable.
    pub fn legacy_amino_multisig(&self) -> Option<&LegacyAminoMultisig> {
        match self {
            Self::LegacyAminoMultisig(amino_multisig) => Some(amino_multisig),
            _ => None,
        }
    }
}

impl Eq for SignerPublicKey {}

impl From<PublicKey> for SignerPublicKey {
    fn from(pk: PublicKey) -> SignerPublicKey {
        Self::Single(pk)
    }
}

impl From<LegacyAminoMultisig> for SignerPublicKey {
    fn from(pk: LegacyAminoMultisig) -> SignerPublicKey {
        Self::LegacyAminoMultisig(pk)
    }
}

impl From<SignerPublicKey> for Any {
    fn from(public_key: SignerPublicKey) -> Any {
        match public_key {
            SignerPublicKey::Single(pk) => pk.into(),
            SignerPublicKey::LegacyAminoMultisig(pk) => pk.into(),
            SignerPublicKey::Any(any) => any,
        }
    }
}

impl TryFrom<Any> for SignerPublicKey {
    type Error = ErrorReport;

    fn try_from(any: Any) -> Result<Self> {
        match any.type_url.as_str() {
            PublicKey::ED25519_TYPE_URL | PublicKey::SECP256K1_TYPE_URL => {
                PublicKey::try_from(any).map(Into::into)
            }
            LegacyAminoMultisig::TYPE_URL => LegacyAminoMultisig::try_from(any).map(Into::into),
            _ => Ok(Self::Any(any)),
        }
    }
}

impl TryFrom<SignerPublicKey> for PublicKey {
    type Error = ErrorReport;

    fn try_from(public_key: SignerPublicKey) -> Result<PublicKey> {
        match public_key {
            SignerPublicKey::Single(pk) => Ok(pk),
            _ => Err(Error::Crypto).wrap_err_with(|| {
                format!(
                    "expected `SignerPublicKey::Single`, got: {}",
                    public_key.type_url()
                )
            }),
        }
    }
}