nibiru_std/proto/buf/cosmos.tx.v1beta1.rs
1// @generated
2/// Tx is the standard type used for broadcasting transactions.
3#[allow(clippy::derive_partial_eq_without_eq)]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct Tx {
6 /// body is the processable content of the transaction
7 #[prost(message, optional, tag="1")]
8 pub body: ::core::option::Option<TxBody>,
9 /// auth_info is the authorization related content of the transaction,
10 /// specifically signers, signer modes and fee
11 #[prost(message, optional, tag="2")]
12 pub auth_info: ::core::option::Option<AuthInfo>,
13 /// signatures is a list of signatures that matches the length and order of
14 /// AuthInfo's signer_infos to allow connecting signature meta information like
15 /// public key and signing mode by position.
16 #[prost(bytes="bytes", repeated, tag="3")]
17 pub signatures: ::prost::alloc::vec::Vec<::prost::bytes::Bytes>,
18}
19/// TxRaw is a variant of Tx that pins the signer's exact binary representation
20/// of body and auth_info. This is used for signing, broadcasting and
21/// verification. The binary `serialize(tx: TxRaw)` is stored in Tendermint and
22/// the hash `sha256(serialize(tx: TxRaw))` becomes the "txhash", commonly used
23/// as the transaction ID.
24#[allow(clippy::derive_partial_eq_without_eq)]
25#[derive(Clone, PartialEq, ::prost::Message)]
26pub struct TxRaw {
27 /// body_bytes is a protobuf serialization of a TxBody that matches the
28 /// representation in SignDoc.
29 #[prost(bytes="bytes", tag="1")]
30 pub body_bytes: ::prost::bytes::Bytes,
31 /// auth_info_bytes is a protobuf serialization of an AuthInfo that matches the
32 /// representation in SignDoc.
33 #[prost(bytes="bytes", tag="2")]
34 pub auth_info_bytes: ::prost::bytes::Bytes,
35 /// signatures is a list of signatures that matches the length and order of
36 /// AuthInfo's signer_infos to allow connecting signature meta information like
37 /// public key and signing mode by position.
38 #[prost(bytes="bytes", repeated, tag="3")]
39 pub signatures: ::prost::alloc::vec::Vec<::prost::bytes::Bytes>,
40}
41/// SignDoc is the type used for generating sign bytes for SIGN_MODE_DIRECT.
42#[allow(clippy::derive_partial_eq_without_eq)]
43#[derive(Clone, PartialEq, ::prost::Message)]
44pub struct SignDoc {
45 /// body_bytes is protobuf serialization of a TxBody that matches the
46 /// representation in TxRaw.
47 #[prost(bytes="bytes", tag="1")]
48 pub body_bytes: ::prost::bytes::Bytes,
49 /// auth_info_bytes is a protobuf serialization of an AuthInfo that matches the
50 /// representation in TxRaw.
51 #[prost(bytes="bytes", tag="2")]
52 pub auth_info_bytes: ::prost::bytes::Bytes,
53 /// chain_id is the unique identifier of the chain this transaction targets.
54 /// It prevents signed transactions from being used on another chain by an
55 /// attacker
56 #[prost(string, tag="3")]
57 pub chain_id: ::prost::alloc::string::String,
58 /// account_number is the account number of the account in state
59 #[prost(uint64, tag="4")]
60 pub account_number: u64,
61}
62/// SignDocDirectAux is the type used for generating sign bytes for
63/// SIGN_MODE_DIRECT_AUX.
64///
65/// Since: cosmos-sdk 0.46
66#[allow(clippy::derive_partial_eq_without_eq)]
67#[derive(Clone, PartialEq, ::prost::Message)]
68pub struct SignDocDirectAux {
69 /// body_bytes is protobuf serialization of a TxBody that matches the
70 /// representation in TxRaw.
71 #[prost(bytes="bytes", tag="1")]
72 pub body_bytes: ::prost::bytes::Bytes,
73 /// public_key is the public key of the signing account.
74 #[prost(message, optional, tag="2")]
75 pub public_key: ::core::option::Option<::prost_types::Any>,
76 /// chain_id is the identifier of the chain this transaction targets.
77 /// It prevents signed transactions from being used on another chain by an
78 /// attacker.
79 #[prost(string, tag="3")]
80 pub chain_id: ::prost::alloc::string::String,
81 /// account_number is the account number of the account in state.
82 #[prost(uint64, tag="4")]
83 pub account_number: u64,
84 /// sequence is the sequence number of the signing account.
85 #[prost(uint64, tag="5")]
86 pub sequence: u64,
87 /// Tip is the optional tip used for transactions fees paid in another denom.
88 /// It should be left empty if the signer is not the tipper for this
89 /// transaction.
90 ///
91 /// This field is ignored if the chain didn't enable tips, i.e. didn't add the
92 /// `TipDecorator` in its posthandler.
93 #[prost(message, optional, tag="6")]
94 pub tip: ::core::option::Option<Tip>,
95}
96/// TxBody is the body of a transaction that all signers sign over.
97#[allow(clippy::derive_partial_eq_without_eq)]
98#[derive(Clone, PartialEq, ::prost::Message)]
99pub struct TxBody {
100 /// messages is a list of messages to be executed. The required signers of
101 /// those messages define the number and order of elements in AuthInfo's
102 /// signer_infos and Tx's signatures. Each required signer address is added to
103 /// the list only the first time it occurs.
104 /// By convention, the first required signer (usually from the first message)
105 /// is referred to as the primary signer and pays the fee for the whole
106 /// transaction.
107 #[prost(message, repeated, tag="1")]
108 pub messages: ::prost::alloc::vec::Vec<::prost_types::Any>,
109 /// memo is any arbitrary note/comment to be added to the transaction.
110 /// WARNING: in clients, any publicly exposed text should not be called memo,
111 /// but should be called `note` instead (see <https://github.com/cosmos/cosmos-sdk/issues/9122>).
112 #[prost(string, tag="2")]
113 pub memo: ::prost::alloc::string::String,
114 /// timeout is the block height after which this transaction will not
115 /// be processed by the chain
116 #[prost(uint64, tag="3")]
117 pub timeout_height: u64,
118 /// extension_options are arbitrary options that can be added by chains
119 /// when the default options are not sufficient. If any of these are present
120 /// and can't be handled, the transaction will be rejected
121 #[prost(message, repeated, tag="1023")]
122 pub extension_options: ::prost::alloc::vec::Vec<::prost_types::Any>,
123 /// extension_options are arbitrary options that can be added by chains
124 /// when the default options are not sufficient. If any of these are present
125 /// and can't be handled, they will be ignored
126 #[prost(message, repeated, tag="2047")]
127 pub non_critical_extension_options: ::prost::alloc::vec::Vec<::prost_types::Any>,
128}
129/// AuthInfo describes the fee and signer modes that are used to sign a
130/// transaction.
131#[allow(clippy::derive_partial_eq_without_eq)]
132#[derive(Clone, PartialEq, ::prost::Message)]
133pub struct AuthInfo {
134 /// signer_infos defines the signing modes for the required signers. The number
135 /// and order of elements must match the required signers from TxBody's
136 /// messages. The first element is the primary signer and the one which pays
137 /// the fee.
138 #[prost(message, repeated, tag="1")]
139 pub signer_infos: ::prost::alloc::vec::Vec<SignerInfo>,
140 /// Fee is the fee and gas limit for the transaction. The first signer is the
141 /// primary signer and the one which pays the fee. The fee can be calculated
142 /// based on the cost of evaluating the body and doing signature verification
143 /// of the signers. This can be estimated via simulation.
144 #[prost(message, optional, tag="2")]
145 pub fee: ::core::option::Option<Fee>,
146 /// Tip is the optional tip used for transactions fees paid in another denom.
147 ///
148 /// This field is ignored if the chain didn't enable tips, i.e. didn't add the
149 /// `TipDecorator` in its posthandler.
150 ///
151 /// Since: cosmos-sdk 0.46
152 #[prost(message, optional, tag="3")]
153 pub tip: ::core::option::Option<Tip>,
154}
155/// SignerInfo describes the public key and signing mode of a single top-level
156/// signer.
157#[allow(clippy::derive_partial_eq_without_eq)]
158#[derive(Clone, PartialEq, ::prost::Message)]
159pub struct SignerInfo {
160 /// public_key is the public key of the signer. It is optional for accounts
161 /// that already exist in state. If unset, the verifier can use the required \
162 /// signer address for this position and lookup the public key.
163 #[prost(message, optional, tag="1")]
164 pub public_key: ::core::option::Option<::prost_types::Any>,
165 /// mode_info describes the signing mode of the signer and is a nested
166 /// structure to support nested multisig pubkey's
167 #[prost(message, optional, tag="2")]
168 pub mode_info: ::core::option::Option<ModeInfo>,
169 /// sequence is the sequence of the account, which describes the
170 /// number of committed transactions signed by a given address. It is used to
171 /// prevent replay attacks.
172 #[prost(uint64, tag="3")]
173 pub sequence: u64,
174}
175/// ModeInfo describes the signing mode of a single or nested multisig signer.
176#[allow(clippy::derive_partial_eq_without_eq)]
177#[derive(Clone, PartialEq, ::prost::Message)]
178pub struct ModeInfo {
179 /// sum is the oneof that specifies whether this represents a single or nested
180 /// multisig signer
181 #[prost(oneof="mode_info::Sum", tags="1, 2")]
182 pub sum: ::core::option::Option<mode_info::Sum>,
183}
184/// Nested message and enum types in `ModeInfo`.
185pub mod mode_info {
186 /// Single is the mode info for a single signer. It is structured as a message
187 /// to allow for additional fields such as locale for SIGN_MODE_TEXTUAL in the
188 /// future
189 #[allow(clippy::derive_partial_eq_without_eq)]
190#[derive(Clone, PartialEq, ::prost::Message)]
191 pub struct Single {
192 /// mode is the signing mode of the single signer
193 #[prost(enumeration="crate::proto::cosmos::tx::signing::v1beta1::SignMode", tag="1")]
194 pub mode: i32,
195 }
196 /// Multi is the mode info for a multisig public key
197 #[allow(clippy::derive_partial_eq_without_eq)]
198#[derive(Clone, PartialEq, ::prost::Message)]
199 pub struct Multi {
200 /// bitarray specifies which keys within the multisig are signing
201 #[prost(message, optional, tag="1")]
202 pub bitarray: ::core::option::Option<crate::proto::cosmos::crypto::multisig::v1beta1::CompactBitArray>,
203 /// mode_infos is the corresponding modes of the signers of the multisig
204 /// which could include nested multisig public keys
205 #[prost(message, repeated, tag="2")]
206 pub mode_infos: ::prost::alloc::vec::Vec<super::ModeInfo>,
207 }
208 /// sum is the oneof that specifies whether this represents a single or nested
209 /// multisig signer
210 #[allow(clippy::derive_partial_eq_without_eq)]
211#[derive(Clone, PartialEq, ::prost::Oneof)]
212 pub enum Sum {
213 /// single represents a single signer
214 #[prost(message, tag="1")]
215 Single(Single),
216 /// multi represents a nested multisig signer
217 #[prost(message, tag="2")]
218 Multi(Multi),
219 }
220}
221/// Fee includes the amount of coins paid in fees and the maximum
222/// gas to be used by the transaction. The ratio yields an effective "gasprice",
223/// which must be above some miminum to be accepted into the mempool.
224#[allow(clippy::derive_partial_eq_without_eq)]
225#[derive(Clone, PartialEq, ::prost::Message)]
226pub struct Fee {
227 /// amount is the amount of coins to be paid as a fee
228 #[prost(message, repeated, tag="1")]
229 pub amount: ::prost::alloc::vec::Vec<crate::proto::cosmos::base::v1beta1::Coin>,
230 /// gas_limit is the maximum gas that can be used in transaction processing
231 /// before an out of gas error occurs
232 #[prost(uint64, tag="2")]
233 pub gas_limit: u64,
234 /// if unset, the first signer is responsible for paying the fees. If set, the specified account must pay the fees.
235 /// the payer must be a tx signer (and thus have signed this field in AuthInfo).
236 /// setting this field does *not* change the ordering of required signers for the transaction.
237 #[prost(string, tag="3")]
238 pub payer: ::prost::alloc::string::String,
239 /// if set, the fee payer (either the first signer or the value of the payer field) requests that a fee grant be used
240 /// to pay fees instead of the fee payer's own balance. If an appropriate fee grant does not exist or the chain does
241 /// not support fee grants, this will fail
242 #[prost(string, tag="4")]
243 pub granter: ::prost::alloc::string::String,
244}
245/// Tip is the tip used for meta-transactions.
246///
247/// Since: cosmos-sdk 0.46
248#[allow(clippy::derive_partial_eq_without_eq)]
249#[derive(Clone, PartialEq, ::prost::Message)]
250pub struct Tip {
251 /// amount is the amount of the tip
252 #[prost(message, repeated, tag="1")]
253 pub amount: ::prost::alloc::vec::Vec<crate::proto::cosmos::base::v1beta1::Coin>,
254 /// tipper is the address of the account paying for the tip
255 #[prost(string, tag="2")]
256 pub tipper: ::prost::alloc::string::String,
257}
258/// AuxSignerData is the intermediary format that an auxiliary signer (e.g. a
259/// tipper) builds and sends to the fee payer (who will build and broadcast the
260/// actual tx). AuxSignerData is not a valid tx in itself, and will be rejected
261/// by the node if sent directly as-is.
262///
263/// Since: cosmos-sdk 0.46
264#[allow(clippy::derive_partial_eq_without_eq)]
265#[derive(Clone, PartialEq, ::prost::Message)]
266pub struct AuxSignerData {
267 /// address is the bech32-encoded address of the auxiliary signer. If using
268 /// AuxSignerData across different chains, the bech32 prefix of the target
269 /// chain (where the final transaction is broadcasted) should be used.
270 #[prost(string, tag="1")]
271 pub address: ::prost::alloc::string::String,
272 /// sign_doc is the SIGN_MODE_DIRECT_AUX sign doc that the auxiliary signer
273 /// signs. Note: we use the same sign doc even if we're signing with
274 /// LEGACY_AMINO_JSON.
275 #[prost(message, optional, tag="2")]
276 pub sign_doc: ::core::option::Option<SignDocDirectAux>,
277 /// mode is the signing mode of the single signer.
278 #[prost(enumeration="super::signing::v1beta1::SignMode", tag="3")]
279 pub mode: i32,
280 /// sig is the signature of the sign doc.
281 #[prost(bytes="bytes", tag="4")]
282 pub sig: ::prost::bytes::Bytes,
283}
284/// GetTxsEventRequest is the request type for the Service.TxsByEvents
285/// RPC method.
286#[allow(clippy::derive_partial_eq_without_eq)]
287#[derive(Clone, PartialEq, ::prost::Message)]
288pub struct GetTxsEventRequest {
289 /// events is the list of transaction event type.
290 #[prost(string, repeated, tag="1")]
291 pub events: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
292 /// pagination defines a pagination for the request.
293 /// Deprecated post v0.46.x: use page and limit instead.
294 #[deprecated]
295 #[prost(message, optional, tag="2")]
296 pub pagination: ::core::option::Option<crate::proto::cosmos::base::query::v1beta1::PageRequest>,
297 #[prost(enumeration="OrderBy", tag="3")]
298 pub order_by: i32,
299 /// page is the page number to query, starts at 1. If not provided, will default to first page.
300 #[prost(uint64, tag="4")]
301 pub page: u64,
302 /// limit is the total number of results to be returned in the result page.
303 /// If left empty it will default to a value to be set by each app.
304 #[prost(uint64, tag="5")]
305 pub limit: u64,
306}
307/// GetTxsEventResponse is the response type for the Service.TxsByEvents
308/// RPC method.
309#[allow(clippy::derive_partial_eq_without_eq)]
310#[derive(Clone, PartialEq, ::prost::Message)]
311pub struct GetTxsEventResponse {
312 /// txs is the list of queried transactions.
313 #[prost(message, repeated, tag="1")]
314 pub txs: ::prost::alloc::vec::Vec<Tx>,
315 /// tx_responses is the list of queried TxResponses.
316 #[prost(message, repeated, tag="2")]
317 pub tx_responses: ::prost::alloc::vec::Vec<crate::proto::cosmos::base::abci::v1beta1::TxResponse>,
318 /// pagination defines a pagination for the response.
319 /// Deprecated post v0.46.x: use total instead.
320 #[deprecated]
321 #[prost(message, optional, tag="3")]
322 pub pagination: ::core::option::Option<crate::proto::cosmos::base::query::v1beta1::PageResponse>,
323 /// total is total number of results available
324 #[prost(uint64, tag="4")]
325 pub total: u64,
326}
327/// BroadcastTxRequest is the request type for the Service.BroadcastTxRequest
328/// RPC method.
329#[allow(clippy::derive_partial_eq_without_eq)]
330#[derive(Clone, PartialEq, ::prost::Message)]
331pub struct BroadcastTxRequest {
332 /// tx_bytes is the raw transaction.
333 #[prost(bytes="bytes", tag="1")]
334 pub tx_bytes: ::prost::bytes::Bytes,
335 #[prost(enumeration="BroadcastMode", tag="2")]
336 pub mode: i32,
337}
338/// BroadcastTxResponse is the response type for the
339/// Service.BroadcastTx method.
340#[allow(clippy::derive_partial_eq_without_eq)]
341#[derive(Clone, PartialEq, ::prost::Message)]
342pub struct BroadcastTxResponse {
343 /// tx_response is the queried TxResponses.
344 #[prost(message, optional, tag="1")]
345 pub tx_response: ::core::option::Option<crate::proto::cosmos::base::abci::v1beta1::TxResponse>,
346}
347/// SimulateRequest is the request type for the Service.Simulate
348/// RPC method.
349#[allow(clippy::derive_partial_eq_without_eq)]
350#[derive(Clone, PartialEq, ::prost::Message)]
351pub struct SimulateRequest {
352 /// tx is the transaction to simulate.
353 /// Deprecated. Send raw tx bytes instead.
354 #[deprecated]
355 #[prost(message, optional, tag="1")]
356 pub tx: ::core::option::Option<Tx>,
357 /// tx_bytes is the raw transaction.
358 ///
359 /// Since: cosmos-sdk 0.43
360 #[prost(bytes="bytes", tag="2")]
361 pub tx_bytes: ::prost::bytes::Bytes,
362}
363/// SimulateResponse is the response type for the
364/// Service.SimulateRPC method.
365#[allow(clippy::derive_partial_eq_without_eq)]
366#[derive(Clone, PartialEq, ::prost::Message)]
367pub struct SimulateResponse {
368 /// gas_info is the information about gas used in the simulation.
369 #[prost(message, optional, tag="1")]
370 pub gas_info: ::core::option::Option<crate::proto::cosmos::base::abci::v1beta1::GasInfo>,
371 /// result is the result of the simulation.
372 #[prost(message, optional, tag="2")]
373 pub result: ::core::option::Option<crate::proto::cosmos::base::abci::v1beta1::Result>,
374}
375/// GetTxRequest is the request type for the Service.GetTx
376/// RPC method.
377#[allow(clippy::derive_partial_eq_without_eq)]
378#[derive(Clone, PartialEq, ::prost::Message)]
379pub struct GetTxRequest {
380 /// hash is the tx hash to query, encoded as a hex string.
381 #[prost(string, tag="1")]
382 pub hash: ::prost::alloc::string::String,
383}
384/// GetTxResponse is the response type for the Service.GetTx method.
385#[allow(clippy::derive_partial_eq_without_eq)]
386#[derive(Clone, PartialEq, ::prost::Message)]
387pub struct GetTxResponse {
388 /// tx is the queried transaction.
389 #[prost(message, optional, tag="1")]
390 pub tx: ::core::option::Option<Tx>,
391 /// tx_response is the queried TxResponses.
392 #[prost(message, optional, tag="2")]
393 pub tx_response: ::core::option::Option<crate::proto::cosmos::base::abci::v1beta1::TxResponse>,
394}
395/// GetBlockWithTxsRequest is the request type for the Service.GetBlockWithTxs
396/// RPC method.
397///
398/// Since: cosmos-sdk 0.45.2
399#[allow(clippy::derive_partial_eq_without_eq)]
400#[derive(Clone, PartialEq, ::prost::Message)]
401pub struct GetBlockWithTxsRequest {
402 /// height is the height of the block to query.
403 #[prost(int64, tag="1")]
404 pub height: i64,
405 /// pagination defines a pagination for the request.
406 #[prost(message, optional, tag="2")]
407 pub pagination: ::core::option::Option<crate::proto::cosmos::base::query::v1beta1::PageRequest>,
408}
409/// GetBlockWithTxsResponse is the response type for the Service.GetBlockWithTxs method.
410///
411/// Since: cosmos-sdk 0.45.2
412#[allow(clippy::derive_partial_eq_without_eq)]
413#[derive(Clone, PartialEq, ::prost::Message)]
414pub struct GetBlockWithTxsResponse {
415 /// txs are the transactions in the block.
416 #[prost(message, repeated, tag="1")]
417 pub txs: ::prost::alloc::vec::Vec<Tx>,
418 #[prost(message, optional, tag="2")]
419 pub block_id: ::core::option::Option<crate::proto::tendermint::types::BlockId>,
420 #[prost(message, optional, tag="3")]
421 pub block: ::core::option::Option<crate::proto::tendermint::types::Block>,
422 /// pagination defines a pagination for the response.
423 #[prost(message, optional, tag="4")]
424 pub pagination: ::core::option::Option<crate::proto::cosmos::base::query::v1beta1::PageResponse>,
425}
426/// TxDecodeRequest is the request type for the Service.TxDecode
427/// RPC method.
428///
429/// Since: cosmos-sdk 0.47
430#[allow(clippy::derive_partial_eq_without_eq)]
431#[derive(Clone, PartialEq, ::prost::Message)]
432pub struct TxDecodeRequest {
433 /// tx_bytes is the raw transaction.
434 #[prost(bytes="bytes", tag="1")]
435 pub tx_bytes: ::prost::bytes::Bytes,
436}
437/// TxDecodeResponse is the response type for the
438/// Service.TxDecode method.
439///
440/// Since: cosmos-sdk 0.47
441#[allow(clippy::derive_partial_eq_without_eq)]
442#[derive(Clone, PartialEq, ::prost::Message)]
443pub struct TxDecodeResponse {
444 /// tx is the decoded transaction.
445 #[prost(message, optional, tag="1")]
446 pub tx: ::core::option::Option<Tx>,
447}
448/// TxEncodeRequest is the request type for the Service.TxEncode
449/// RPC method.
450///
451/// Since: cosmos-sdk 0.47
452#[allow(clippy::derive_partial_eq_without_eq)]
453#[derive(Clone, PartialEq, ::prost::Message)]
454pub struct TxEncodeRequest {
455 /// tx is the transaction to encode.
456 #[prost(message, optional, tag="1")]
457 pub tx: ::core::option::Option<Tx>,
458}
459/// TxEncodeResponse is the response type for the
460/// Service.TxEncode method.
461///
462/// Since: cosmos-sdk 0.47
463#[allow(clippy::derive_partial_eq_without_eq)]
464#[derive(Clone, PartialEq, ::prost::Message)]
465pub struct TxEncodeResponse {
466 /// tx_bytes is the encoded transaction bytes.
467 #[prost(bytes="bytes", tag="1")]
468 pub tx_bytes: ::prost::bytes::Bytes,
469}
470/// TxEncodeAminoRequest is the request type for the Service.TxEncodeAmino
471/// RPC method.
472///
473/// Since: cosmos-sdk 0.47
474#[allow(clippy::derive_partial_eq_without_eq)]
475#[derive(Clone, PartialEq, ::prost::Message)]
476pub struct TxEncodeAminoRequest {
477 #[prost(string, tag="1")]
478 pub amino_json: ::prost::alloc::string::String,
479}
480/// TxEncodeAminoResponse is the response type for the Service.TxEncodeAmino
481/// RPC method.
482///
483/// Since: cosmos-sdk 0.47
484#[allow(clippy::derive_partial_eq_without_eq)]
485#[derive(Clone, PartialEq, ::prost::Message)]
486pub struct TxEncodeAminoResponse {
487 #[prost(bytes="bytes", tag="1")]
488 pub amino_binary: ::prost::bytes::Bytes,
489}
490/// TxDecodeAminoRequest is the request type for the Service.TxDecodeAmino
491/// RPC method.
492///
493/// Since: cosmos-sdk 0.47
494#[allow(clippy::derive_partial_eq_without_eq)]
495#[derive(Clone, PartialEq, ::prost::Message)]
496pub struct TxDecodeAminoRequest {
497 #[prost(bytes="bytes", tag="1")]
498 pub amino_binary: ::prost::bytes::Bytes,
499}
500/// TxDecodeAminoResponse is the response type for the Service.TxDecodeAmino
501/// RPC method.
502///
503/// Since: cosmos-sdk 0.47
504#[allow(clippy::derive_partial_eq_without_eq)]
505#[derive(Clone, PartialEq, ::prost::Message)]
506pub struct TxDecodeAminoResponse {
507 #[prost(string, tag="1")]
508 pub amino_json: ::prost::alloc::string::String,
509}
510/// OrderBy defines the sorting order
511#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
512#[repr(i32)]
513pub enum OrderBy {
514 /// ORDER_BY_UNSPECIFIED specifies an unknown sorting order. OrderBy defaults to ASC in this case.
515 Unspecified = 0,
516 /// ORDER_BY_ASC defines ascending order
517 Asc = 1,
518 /// ORDER_BY_DESC defines descending order
519 Desc = 2,
520}
521impl OrderBy {
522 /// String value of the enum field names used in the ProtoBuf definition.
523 ///
524 /// The values are not transformed in any way and thus are considered stable
525 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
526 pub fn as_str_name(&self) -> &'static str {
527 match self {
528 OrderBy::Unspecified => "ORDER_BY_UNSPECIFIED",
529 OrderBy::Asc => "ORDER_BY_ASC",
530 OrderBy::Desc => "ORDER_BY_DESC",
531 }
532 }
533 /// Creates an enum from field names used in the ProtoBuf definition.
534 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
535 match value {
536 "ORDER_BY_UNSPECIFIED" => Some(Self::Unspecified),
537 "ORDER_BY_ASC" => Some(Self::Asc),
538 "ORDER_BY_DESC" => Some(Self::Desc),
539 _ => None,
540 }
541 }
542}
543/// BroadcastMode specifies the broadcast mode for the TxService.Broadcast RPC method.
544#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
545#[repr(i32)]
546pub enum BroadcastMode {
547 /// zero-value for mode ordering
548 Unspecified = 0,
549 /// DEPRECATED: use BROADCAST_MODE_SYNC instead,
550 /// BROADCAST_MODE_BLOCK is not supported by the SDK from v0.47.x onwards.
551 Block = 1,
552 /// BROADCAST_MODE_SYNC defines a tx broadcasting mode where the client waits for
553 /// a CheckTx execution response only.
554 Sync = 2,
555 /// BROADCAST_MODE_ASYNC defines a tx broadcasting mode where the client returns
556 /// immediately.
557 Async = 3,
558}
559impl BroadcastMode {
560 /// String value of the enum field names used in the ProtoBuf definition.
561 ///
562 /// The values are not transformed in any way and thus are considered stable
563 /// (if the ProtoBuf definition does not change) and safe for programmatic use.
564 pub fn as_str_name(&self) -> &'static str {
565 match self {
566 BroadcastMode::Unspecified => "BROADCAST_MODE_UNSPECIFIED",
567 BroadcastMode::Block => "BROADCAST_MODE_BLOCK",
568 BroadcastMode::Sync => "BROADCAST_MODE_SYNC",
569 BroadcastMode::Async => "BROADCAST_MODE_ASYNC",
570 }
571 }
572 /// Creates an enum from field names used in the ProtoBuf definition.
573 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
574 match value {
575 "BROADCAST_MODE_UNSPECIFIED" => Some(Self::Unspecified),
576 "BROADCAST_MODE_BLOCK" => Some(Self::Block),
577 "BROADCAST_MODE_SYNC" => Some(Self::Sync),
578 "BROADCAST_MODE_ASYNC" => Some(Self::Async),
579 _ => None,
580 }
581 }
582}
583// @@protoc_insertion_point(module)