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

/// Tx is the standard type used for broadcasting transactions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tx {
    /// body is the processable content of the transaction
    #[prost(message, optional, tag="1")]
    pub body: ::std::option::Option<TxBody>,
    /// auth_info is the authorization related content of the transaction, specifically
    /// signers, signer modes and fee
    #[prost(message, optional, tag="2")]
    pub auth_info: ::std::option::Option<AuthInfo>,
    /// signatures is a list of signatures that matches the length and order of AuthInfo's signer_infos to
    /// allow connecting signature meta information like public key and signing mode by position.
    #[prost(bytes, repeated, tag="3")]
    pub signatures: ::std::vec::Vec<std::vec::Vec<u8>>,
}
/// TxRaw is a variant of Tx that pins the signer's exact binary representation of body and
/// auth_info. This is used for signing, broadcasting and verification. The binary
/// `serialize(tx: TxRaw)` is stored in Tendermint and the hash `sha256(serialize(tx: TxRaw))`
/// becomes the "txhash", commonly used as the transaction ID.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TxRaw {
    /// body_bytes is a protobuf serialization of a TxBody that matches the representation in SignDoc.
    #[prost(bytes, tag="1")]
    pub body_bytes: std::vec::Vec<u8>,
    /// auth_info_bytes is a protobuf serialization of an AuthInfo that matches the representation in SignDoc.
    #[prost(bytes, tag="2")]
    pub auth_info_bytes: std::vec::Vec<u8>,
    /// signatures is a list of signatures that matches the length and order of AuthInfo's signer_infos to
    /// allow connecting signature meta information like public key and signing mode by position.
    #[prost(bytes, repeated, tag="3")]
    pub signatures: ::std::vec::Vec<std::vec::Vec<u8>>,
}
/// SignDoc is the type used for generating sign bytes for SIGN_MODE_DIRECT.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignDoc {
    /// body_bytes is protobuf serialization of a TxBody that matches the representation in TxRaw.
    #[prost(bytes, tag="1")]
    pub body_bytes: std::vec::Vec<u8>,
    /// auth_info_bytes is a protobuf serialization of an AuthInfo that matches the representation in TxRaw.
    #[prost(bytes, tag="2")]
    pub auth_info_bytes: std::vec::Vec<u8>,
    /// chain_id is the unique identifier of the chain this transaction targets.
    /// It prevents signed transactions from being used on another chain by an
    /// attacker
    #[prost(string, tag="3")]
    pub chain_id: std::string::String,
    /// account_number is the account number of the account in state
    #[prost(uint64, tag="4")]
    pub account_number: u64,
}
/// TxBody is the body of a transaction that all signers sign over.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TxBody {
    /// messages is a list of messages to be executed. The required signers of those messages define
    /// the number and order of elements in AuthInfo's signer_infos and Tx's signatures.
    /// Each required signer address is added to the list only the first time it occurs.
    ///
    /// By convention, the first required signer (usually from the first message) is referred
    /// to as the primary signer and pays the fee for the whole transaction.
    #[prost(message, repeated, tag="1")]
    pub messages: ::std::vec::Vec<::prost_types::Any>,
    /// memo is any arbitrary memo to be added to the transaction
    #[prost(string, tag="2")]
    pub memo: std::string::String,
    /// timeout is the block height after which this transaction will not
    /// be processed by the chain
    #[prost(uint64, tag="3")]
    pub timeout_height: u64,
    /// extension_options are arbitrary options that can be added by chains
    /// when the default options are not sufficient. If any of these are present
    /// and can't be handled, the transaction will be rejected
    #[prost(message, repeated, tag="1023")]
    pub extension_options: ::std::vec::Vec<::prost_types::Any>,
    /// extension_options are arbitrary options that can be added by chains
    /// when the default options are not sufficient. If any of these are present
    /// and can't be handled, they will be ignored
    #[prost(message, repeated, tag="2047")]
    pub non_critical_extension_options: ::std::vec::Vec<::prost_types::Any>,
}
/// AuthInfo describes the fee and signer modes that are used to sign a transaction.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AuthInfo {
    /// signer_infos defines the signing modes for the required signers. The number
    /// and order of elements must match the required signers from TxBody's messages.
    /// The first element is the primary signer and the one which pays the fee.
    #[prost(message, repeated, tag="1")]
    pub signer_infos: ::std::vec::Vec<SignerInfo>,
    /// Fee is the fee and gas limit for the transaction. The first signer is the
    /// primary signer and the one which pays the fee. The fee can be calculated
    /// based on the cost of evaluating the body and doing signature verification
    /// of the signers. This can be estimated via simulation.
    #[prost(message, optional, tag="2")]
    pub fee: ::std::option::Option<Fee>,
}
/// SignerInfo describes the public key and signing mode of a single top-level signer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignerInfo {
    /// public_key is the public key 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.
    #[prost(message, optional, tag="1")]
    pub public_key: ::std::option::Option<super::super::base::crypto::v1beta1::PublicKey>,
    /// mode_info describes the signing mode of the signer and is a nested
    /// structure to support nested multisig pubkey's
    #[prost(message, optional, tag="2")]
    pub mode_info: ::std::option::Option<ModeInfo>,
    /// sequence is the sequence of the account, which describes the
    /// number of committed transactions signed by a given address. It is used to prevent
    /// replay attacks.
    #[prost(uint64, tag="3")]
    pub sequence: u64,
}
/// ModeInfo describes the signing mode of a single or nested multisig signer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ModeInfo {
    /// sum is the oneof that specifies whether this represents a single or nested
    /// multisig signer
    #[prost(oneof="mode_info::Sum", tags="1, 2")]
    pub sum: ::std::option::Option<mode_info::Sum>,
}
pub mod mode_info {
    /// 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, PartialEq, ::prost::Message)]
    pub struct Single {
        /// mode is the signing mode of the single signer
        #[prost(enumeration="super::super::signing::v1beta1::SignMode", tag="1")]
        pub mode: i32,
    }
    /// Multi is the mode info for a multisig public key
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Multi {
        /// bitarray specifies which keys within the multisig are signing
        #[prost(message, optional, tag="1")]
        pub bitarray: ::std::option::Option<super::super::super::base::crypto::v1beta1::CompactBitArray>,
        /// mode_infos is the corresponding modes of the signers of the multisig
        /// which could include nested multisig public keys
        #[prost(message, repeated, tag="2")]
        pub mode_infos: ::std::vec::Vec<super::ModeInfo>,
    }
    /// sum is the oneof that specifies whether this represents a single or nested
    /// multisig signer
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Sum {
        /// single represents a single signer
        #[prost(message, tag="1")]
        Single(Single),
        /// multi represents a nested multisig signer
        #[prost(message, tag="2")]
        Multi(Multi),
    }
}
/// Fee includes the amount of coins paid in fees and the maximum
/// gas to be used by the transaction. The ratio yields an effective "gasprice",
/// which must be above some miminum to be accepted into the mempool.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Fee {
    /// amount is the amount of coins to be paid as a fee
    #[prost(message, repeated, tag="1")]
    pub amount: ::std::vec::Vec<super::super::base::v1beta1::Coin>,
    /// gas_limit is the maximum gas that can be used in transaction processing
    /// before an out of gas error occurs
    #[prost(uint64, tag="2")]
    pub gas_limit: u64,
}