persistence_std/types/tendermint/
abci.rs

1use persistence_std_derive::CosmwasmExt;
2#[allow(clippy::derive_partial_eq_without_eq)]
3#[derive(
4    Clone,
5    PartialEq,
6    Eq,
7    ::prost::Message,
8    ::serde::Serialize,
9    ::serde::Deserialize,
10    ::schemars::JsonSchema,
11    CosmwasmExt,
12)]
13#[proto_message(type_url = "/tendermint.abci.Request")]
14pub struct Request {
15    #[prost(
16        oneof = "request::Value",
17        tags = "1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17"
18    )]
19    pub value: ::core::option::Option<request::Value>,
20}
21/// Nested message and enum types in `Request`.
22pub mod request {
23    use persistence_std_derive::CosmwasmExt;
24    #[allow(clippy::derive_partial_eq_without_eq)]
25    #[derive(
26        Clone,
27        PartialEq,
28        Eq,
29        ::prost::Oneof,
30        ::schemars::JsonSchema,
31        ::serde::Serialize,
32        ::serde::Deserialize,
33    )]
34    pub enum Value {
35        #[prost(message, tag = "1")]
36        Echo(super::RequestEcho),
37        #[prost(message, tag = "2")]
38        Flush(super::RequestFlush),
39        #[prost(message, tag = "3")]
40        Info(super::RequestInfo),
41        #[prost(message, tag = "5")]
42        InitChain(super::RequestInitChain),
43        #[prost(message, tag = "6")]
44        Query(super::RequestQuery),
45        #[prost(message, tag = "7")]
46        BeginBlock(super::RequestBeginBlock),
47        #[prost(message, tag = "8")]
48        CheckTx(super::RequestCheckTx),
49        #[prost(message, tag = "9")]
50        DeliverTx(super::RequestDeliverTx),
51        #[prost(message, tag = "10")]
52        EndBlock(super::RequestEndBlock),
53        #[prost(message, tag = "11")]
54        Commit(super::RequestCommit),
55        #[prost(message, tag = "12")]
56        ListSnapshots(super::RequestListSnapshots),
57        #[prost(message, tag = "13")]
58        OfferSnapshot(super::RequestOfferSnapshot),
59        #[prost(message, tag = "14")]
60        LoadSnapshotChunk(super::RequestLoadSnapshotChunk),
61        #[prost(message, tag = "15")]
62        ApplySnapshotChunk(super::RequestApplySnapshotChunk),
63        #[prost(message, tag = "16")]
64        PrepareProposal(super::RequestPrepareProposal),
65        #[prost(message, tag = "17")]
66        ProcessProposal(super::RequestProcessProposal),
67    }
68}
69#[allow(clippy::derive_partial_eq_without_eq)]
70#[derive(
71    Clone,
72    PartialEq,
73    Eq,
74    ::prost::Message,
75    ::serde::Serialize,
76    ::serde::Deserialize,
77    ::schemars::JsonSchema,
78    CosmwasmExt,
79)]
80#[proto_message(type_url = "/tendermint.abci.RequestEcho")]
81pub struct RequestEcho {
82    #[prost(string, tag = "1")]
83    pub message: ::prost::alloc::string::String,
84}
85#[allow(clippy::derive_partial_eq_without_eq)]
86#[derive(
87    Clone,
88    PartialEq,
89    Eq,
90    ::prost::Message,
91    ::serde::Serialize,
92    ::serde::Deserialize,
93    ::schemars::JsonSchema,
94    CosmwasmExt,
95)]
96#[proto_message(type_url = "/tendermint.abci.RequestFlush")]
97pub struct RequestFlush {}
98#[allow(clippy::derive_partial_eq_without_eq)]
99#[derive(
100    Clone,
101    PartialEq,
102    Eq,
103    ::prost::Message,
104    ::serde::Serialize,
105    ::serde::Deserialize,
106    ::schemars::JsonSchema,
107    CosmwasmExt,
108)]
109#[proto_message(type_url = "/tendermint.abci.RequestInfo")]
110pub struct RequestInfo {
111    #[prost(string, tag = "1")]
112    pub version: ::prost::alloc::string::String,
113    #[prost(uint64, tag = "2")]
114    #[serde(
115        serialize_with = "crate::serde::as_str::serialize",
116        deserialize_with = "crate::serde::as_str::deserialize"
117    )]
118    pub block_version: u64,
119    #[prost(uint64, tag = "3")]
120    #[serde(
121        serialize_with = "crate::serde::as_str::serialize",
122        deserialize_with = "crate::serde::as_str::deserialize"
123    )]
124    pub p2p_version: u64,
125    #[prost(string, tag = "4")]
126    pub abci_version: ::prost::alloc::string::String,
127}
128#[allow(clippy::derive_partial_eq_without_eq)]
129#[derive(
130    Clone,
131    PartialEq,
132    Eq,
133    ::prost::Message,
134    ::serde::Serialize,
135    ::serde::Deserialize,
136    ::schemars::JsonSchema,
137    CosmwasmExt,
138)]
139#[proto_message(type_url = "/tendermint.abci.RequestInitChain")]
140pub struct RequestInitChain {
141    #[prost(message, optional, tag = "1")]
142    pub time: ::core::option::Option<crate::shim::Timestamp>,
143    #[prost(string, tag = "2")]
144    #[serde(alias = "chainID")]
145    pub chain_id: ::prost::alloc::string::String,
146    #[prost(message, optional, tag = "3")]
147    pub consensus_params: ::core::option::Option<super::types::ConsensusParams>,
148    #[prost(message, repeated, tag = "4")]
149    pub validators: ::prost::alloc::vec::Vec<ValidatorUpdate>,
150    #[prost(bytes = "vec", tag = "5")]
151    pub app_state_bytes: ::prost::alloc::vec::Vec<u8>,
152    #[prost(int64, tag = "6")]
153    #[serde(
154        serialize_with = "crate::serde::as_str::serialize",
155        deserialize_with = "crate::serde::as_str::deserialize"
156    )]
157    pub initial_height: i64,
158}
159#[allow(clippy::derive_partial_eq_without_eq)]
160#[derive(
161    Clone,
162    PartialEq,
163    Eq,
164    ::prost::Message,
165    ::serde::Serialize,
166    ::serde::Deserialize,
167    ::schemars::JsonSchema,
168    CosmwasmExt,
169)]
170#[proto_message(type_url = "/tendermint.abci.RequestQuery")]
171pub struct RequestQuery {
172    #[prost(bytes = "vec", tag = "1")]
173    pub data: ::prost::alloc::vec::Vec<u8>,
174    #[prost(string, tag = "2")]
175    pub path: ::prost::alloc::string::String,
176    #[prost(int64, tag = "3")]
177    #[serde(
178        serialize_with = "crate::serde::as_str::serialize",
179        deserialize_with = "crate::serde::as_str::deserialize"
180    )]
181    pub height: i64,
182    #[prost(bool, tag = "4")]
183    pub prove: bool,
184}
185#[allow(clippy::derive_partial_eq_without_eq)]
186#[derive(
187    Clone,
188    PartialEq,
189    Eq,
190    ::prost::Message,
191    ::serde::Serialize,
192    ::serde::Deserialize,
193    ::schemars::JsonSchema,
194    CosmwasmExt,
195)]
196#[proto_message(type_url = "/tendermint.abci.RequestBeginBlock")]
197pub struct RequestBeginBlock {
198    #[prost(bytes = "vec", tag = "1")]
199    pub hash: ::prost::alloc::vec::Vec<u8>,
200    #[prost(message, optional, tag = "2")]
201    pub header: ::core::option::Option<super::types::Header>,
202    #[prost(message, optional, tag = "3")]
203    pub last_commit_info: ::core::option::Option<CommitInfo>,
204    #[prost(message, repeated, tag = "4")]
205    pub byzantine_validators: ::prost::alloc::vec::Vec<Misbehavior>,
206}
207#[allow(clippy::derive_partial_eq_without_eq)]
208#[derive(
209    Clone,
210    PartialEq,
211    Eq,
212    ::prost::Message,
213    ::serde::Serialize,
214    ::serde::Deserialize,
215    ::schemars::JsonSchema,
216    CosmwasmExt,
217)]
218#[proto_message(type_url = "/tendermint.abci.RequestCheckTx")]
219pub struct RequestCheckTx {
220    #[prost(bytes = "vec", tag = "1")]
221    pub tx: ::prost::alloc::vec::Vec<u8>,
222    #[prost(enumeration = "CheckTxType", tag = "2")]
223    #[serde(
224        serialize_with = "check_tx_type_serde::serialize",
225        deserialize_with = "check_tx_type_serde::deserialize"
226    )]
227    pub r#type: i32,
228}
229#[allow(clippy::derive_partial_eq_without_eq)]
230#[derive(
231    Clone,
232    PartialEq,
233    Eq,
234    ::prost::Message,
235    ::serde::Serialize,
236    ::serde::Deserialize,
237    ::schemars::JsonSchema,
238    CosmwasmExt,
239)]
240#[proto_message(type_url = "/tendermint.abci.RequestDeliverTx")]
241pub struct RequestDeliverTx {
242    #[prost(bytes = "vec", tag = "1")]
243    pub tx: ::prost::alloc::vec::Vec<u8>,
244}
245#[allow(clippy::derive_partial_eq_without_eq)]
246#[derive(
247    Clone,
248    PartialEq,
249    Eq,
250    ::prost::Message,
251    ::serde::Serialize,
252    ::serde::Deserialize,
253    ::schemars::JsonSchema,
254    CosmwasmExt,
255)]
256#[proto_message(type_url = "/tendermint.abci.RequestEndBlock")]
257pub struct RequestEndBlock {
258    #[prost(int64, tag = "1")]
259    #[serde(
260        serialize_with = "crate::serde::as_str::serialize",
261        deserialize_with = "crate::serde::as_str::deserialize"
262    )]
263    pub height: i64,
264}
265#[allow(clippy::derive_partial_eq_without_eq)]
266#[derive(
267    Clone,
268    PartialEq,
269    Eq,
270    ::prost::Message,
271    ::serde::Serialize,
272    ::serde::Deserialize,
273    ::schemars::JsonSchema,
274    CosmwasmExt,
275)]
276#[proto_message(type_url = "/tendermint.abci.RequestCommit")]
277pub struct RequestCommit {}
278/// lists available snapshots
279#[allow(clippy::derive_partial_eq_without_eq)]
280#[derive(
281    Clone,
282    PartialEq,
283    Eq,
284    ::prost::Message,
285    ::serde::Serialize,
286    ::serde::Deserialize,
287    ::schemars::JsonSchema,
288    CosmwasmExt,
289)]
290#[proto_message(type_url = "/tendermint.abci.RequestListSnapshots")]
291pub struct RequestListSnapshots {}
292/// offers a snapshot to the application
293#[allow(clippy::derive_partial_eq_without_eq)]
294#[derive(
295    Clone,
296    PartialEq,
297    Eq,
298    ::prost::Message,
299    ::serde::Serialize,
300    ::serde::Deserialize,
301    ::schemars::JsonSchema,
302    CosmwasmExt,
303)]
304#[proto_message(type_url = "/tendermint.abci.RequestOfferSnapshot")]
305pub struct RequestOfferSnapshot {
306    /// snapshot offered by peers
307    #[prost(message, optional, tag = "1")]
308    pub snapshot: ::core::option::Option<Snapshot>,
309    /// light client-verified app hash for snapshot height
310    #[prost(bytes = "vec", tag = "2")]
311    pub app_hash: ::prost::alloc::vec::Vec<u8>,
312}
313/// loads a snapshot chunk
314#[allow(clippy::derive_partial_eq_without_eq)]
315#[derive(
316    Clone,
317    PartialEq,
318    Eq,
319    ::prost::Message,
320    ::serde::Serialize,
321    ::serde::Deserialize,
322    ::schemars::JsonSchema,
323    CosmwasmExt,
324)]
325#[proto_message(type_url = "/tendermint.abci.RequestLoadSnapshotChunk")]
326pub struct RequestLoadSnapshotChunk {
327    #[prost(uint64, tag = "1")]
328    #[serde(
329        serialize_with = "crate::serde::as_str::serialize",
330        deserialize_with = "crate::serde::as_str::deserialize"
331    )]
332    pub height: u64,
333    #[prost(uint32, tag = "2")]
334    #[serde(
335        serialize_with = "crate::serde::as_str::serialize",
336        deserialize_with = "crate::serde::as_str::deserialize"
337    )]
338    pub format: u32,
339    #[prost(uint32, tag = "3")]
340    #[serde(
341        serialize_with = "crate::serde::as_str::serialize",
342        deserialize_with = "crate::serde::as_str::deserialize"
343    )]
344    pub chunk: u32,
345}
346/// Applies a snapshot chunk
347#[allow(clippy::derive_partial_eq_without_eq)]
348#[derive(
349    Clone,
350    PartialEq,
351    Eq,
352    ::prost::Message,
353    ::serde::Serialize,
354    ::serde::Deserialize,
355    ::schemars::JsonSchema,
356    CosmwasmExt,
357)]
358#[proto_message(type_url = "/tendermint.abci.RequestApplySnapshotChunk")]
359pub struct RequestApplySnapshotChunk {
360    #[prost(uint32, tag = "1")]
361    #[serde(
362        serialize_with = "crate::serde::as_str::serialize",
363        deserialize_with = "crate::serde::as_str::deserialize"
364    )]
365    pub index: u32,
366    #[prost(bytes = "vec", tag = "2")]
367    pub chunk: ::prost::alloc::vec::Vec<u8>,
368    #[prost(string, tag = "3")]
369    pub sender: ::prost::alloc::string::String,
370}
371#[allow(clippy::derive_partial_eq_without_eq)]
372#[derive(
373    Clone,
374    PartialEq,
375    Eq,
376    ::prost::Message,
377    ::serde::Serialize,
378    ::serde::Deserialize,
379    ::schemars::JsonSchema,
380    CosmwasmExt,
381)]
382#[proto_message(type_url = "/tendermint.abci.RequestPrepareProposal")]
383pub struct RequestPrepareProposal {
384    /// the modified transactions cannot exceed this size.
385    #[prost(int64, tag = "1")]
386    #[serde(
387        serialize_with = "crate::serde::as_str::serialize",
388        deserialize_with = "crate::serde::as_str::deserialize"
389    )]
390    pub max_tx_bytes: i64,
391    /// txs is an array of transactions that will be included in a block,
392    /// sent to the app for possible modifications.
393    #[prost(bytes = "vec", repeated, tag = "2")]
394    pub txs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
395    #[prost(message, optional, tag = "3")]
396    pub local_last_commit: ::core::option::Option<ExtendedCommitInfo>,
397    #[prost(message, repeated, tag = "4")]
398    pub misbehavior: ::prost::alloc::vec::Vec<Misbehavior>,
399    #[prost(int64, tag = "5")]
400    #[serde(
401        serialize_with = "crate::serde::as_str::serialize",
402        deserialize_with = "crate::serde::as_str::deserialize"
403    )]
404    pub height: i64,
405    #[prost(message, optional, tag = "6")]
406    pub time: ::core::option::Option<crate::shim::Timestamp>,
407    #[prost(bytes = "vec", tag = "7")]
408    pub next_validators_hash: ::prost::alloc::vec::Vec<u8>,
409    /// address of the public key of the validator proposing the block.
410    #[prost(bytes = "vec", tag = "8")]
411    pub proposer_address: ::prost::alloc::vec::Vec<u8>,
412}
413#[allow(clippy::derive_partial_eq_without_eq)]
414#[derive(
415    Clone,
416    PartialEq,
417    Eq,
418    ::prost::Message,
419    ::serde::Serialize,
420    ::serde::Deserialize,
421    ::schemars::JsonSchema,
422    CosmwasmExt,
423)]
424#[proto_message(type_url = "/tendermint.abci.RequestProcessProposal")]
425pub struct RequestProcessProposal {
426    #[prost(bytes = "vec", repeated, tag = "1")]
427    pub txs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
428    #[prost(message, optional, tag = "2")]
429    pub proposed_last_commit: ::core::option::Option<CommitInfo>,
430    #[prost(message, repeated, tag = "3")]
431    pub misbehavior: ::prost::alloc::vec::Vec<Misbehavior>,
432    /// hash is the merkle root hash of the fields of the proposed block.
433    #[prost(bytes = "vec", tag = "4")]
434    pub hash: ::prost::alloc::vec::Vec<u8>,
435    #[prost(int64, tag = "5")]
436    #[serde(
437        serialize_with = "crate::serde::as_str::serialize",
438        deserialize_with = "crate::serde::as_str::deserialize"
439    )]
440    pub height: i64,
441    #[prost(message, optional, tag = "6")]
442    pub time: ::core::option::Option<crate::shim::Timestamp>,
443    #[prost(bytes = "vec", tag = "7")]
444    pub next_validators_hash: ::prost::alloc::vec::Vec<u8>,
445    /// address of the public key of the original proposer of the block.
446    #[prost(bytes = "vec", tag = "8")]
447    pub proposer_address: ::prost::alloc::vec::Vec<u8>,
448}
449#[allow(clippy::derive_partial_eq_without_eq)]
450#[derive(
451    Clone,
452    PartialEq,
453    Eq,
454    ::prost::Message,
455    ::serde::Serialize,
456    ::serde::Deserialize,
457    ::schemars::JsonSchema,
458    CosmwasmExt,
459)]
460#[proto_message(type_url = "/tendermint.abci.Response")]
461pub struct Response {
462    #[prost(
463        oneof = "response::Value",
464        tags = "1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18"
465    )]
466    pub value: ::core::option::Option<response::Value>,
467}
468/// Nested message and enum types in `Response`.
469pub mod response {
470    use persistence_std_derive::CosmwasmExt;
471    #[allow(clippy::derive_partial_eq_without_eq)]
472    #[derive(
473        Clone,
474        PartialEq,
475        Eq,
476        ::prost::Oneof,
477        ::schemars::JsonSchema,
478        ::serde::Serialize,
479        ::serde::Deserialize,
480    )]
481    pub enum Value {
482        #[prost(message, tag = "1")]
483        Exception(super::ResponseException),
484        #[prost(message, tag = "2")]
485        Echo(super::ResponseEcho),
486        #[prost(message, tag = "3")]
487        Flush(super::ResponseFlush),
488        #[prost(message, tag = "4")]
489        Info(super::ResponseInfo),
490        #[prost(message, tag = "6")]
491        InitChain(super::ResponseInitChain),
492        #[prost(message, tag = "7")]
493        Query(super::ResponseQuery),
494        #[prost(message, tag = "8")]
495        BeginBlock(super::ResponseBeginBlock),
496        #[prost(message, tag = "9")]
497        CheckTx(super::ResponseCheckTx),
498        #[prost(message, tag = "10")]
499        DeliverTx(super::ResponseDeliverTx),
500        #[prost(message, tag = "11")]
501        EndBlock(super::ResponseEndBlock),
502        #[prost(message, tag = "12")]
503        Commit(super::ResponseCommit),
504        #[prost(message, tag = "13")]
505        ListSnapshots(super::ResponseListSnapshots),
506        #[prost(message, tag = "14")]
507        OfferSnapshot(super::ResponseOfferSnapshot),
508        #[prost(message, tag = "15")]
509        LoadSnapshotChunk(super::ResponseLoadSnapshotChunk),
510        #[prost(message, tag = "16")]
511        ApplySnapshotChunk(super::ResponseApplySnapshotChunk),
512        #[prost(message, tag = "17")]
513        PrepareProposal(super::ResponsePrepareProposal),
514        #[prost(message, tag = "18")]
515        ProcessProposal(super::ResponseProcessProposal),
516    }
517}
518/// nondeterministic
519#[allow(clippy::derive_partial_eq_without_eq)]
520#[derive(
521    Clone,
522    PartialEq,
523    Eq,
524    ::prost::Message,
525    ::serde::Serialize,
526    ::serde::Deserialize,
527    ::schemars::JsonSchema,
528    CosmwasmExt,
529)]
530#[proto_message(type_url = "/tendermint.abci.ResponseException")]
531pub struct ResponseException {
532    #[prost(string, tag = "1")]
533    pub error: ::prost::alloc::string::String,
534}
535#[allow(clippy::derive_partial_eq_without_eq)]
536#[derive(
537    Clone,
538    PartialEq,
539    Eq,
540    ::prost::Message,
541    ::serde::Serialize,
542    ::serde::Deserialize,
543    ::schemars::JsonSchema,
544    CosmwasmExt,
545)]
546#[proto_message(type_url = "/tendermint.abci.ResponseEcho")]
547pub struct ResponseEcho {
548    #[prost(string, tag = "1")]
549    pub message: ::prost::alloc::string::String,
550}
551#[allow(clippy::derive_partial_eq_without_eq)]
552#[derive(
553    Clone,
554    PartialEq,
555    Eq,
556    ::prost::Message,
557    ::serde::Serialize,
558    ::serde::Deserialize,
559    ::schemars::JsonSchema,
560    CosmwasmExt,
561)]
562#[proto_message(type_url = "/tendermint.abci.ResponseFlush")]
563pub struct ResponseFlush {}
564#[allow(clippy::derive_partial_eq_without_eq)]
565#[derive(
566    Clone,
567    PartialEq,
568    Eq,
569    ::prost::Message,
570    ::serde::Serialize,
571    ::serde::Deserialize,
572    ::schemars::JsonSchema,
573    CosmwasmExt,
574)]
575#[proto_message(type_url = "/tendermint.abci.ResponseInfo")]
576pub struct ResponseInfo {
577    #[prost(string, tag = "1")]
578    pub data: ::prost::alloc::string::String,
579    #[prost(string, tag = "2")]
580    pub version: ::prost::alloc::string::String,
581    #[prost(uint64, tag = "3")]
582    #[serde(
583        serialize_with = "crate::serde::as_str::serialize",
584        deserialize_with = "crate::serde::as_str::deserialize"
585    )]
586    pub app_version: u64,
587    #[prost(int64, tag = "4")]
588    #[serde(
589        serialize_with = "crate::serde::as_str::serialize",
590        deserialize_with = "crate::serde::as_str::deserialize"
591    )]
592    pub last_block_height: i64,
593    #[prost(bytes = "vec", tag = "5")]
594    pub last_block_app_hash: ::prost::alloc::vec::Vec<u8>,
595}
596#[allow(clippy::derive_partial_eq_without_eq)]
597#[derive(
598    Clone,
599    PartialEq,
600    Eq,
601    ::prost::Message,
602    ::serde::Serialize,
603    ::serde::Deserialize,
604    ::schemars::JsonSchema,
605    CosmwasmExt,
606)]
607#[proto_message(type_url = "/tendermint.abci.ResponseInitChain")]
608pub struct ResponseInitChain {
609    #[prost(message, optional, tag = "1")]
610    pub consensus_params: ::core::option::Option<super::types::ConsensusParams>,
611    #[prost(message, repeated, tag = "2")]
612    pub validators: ::prost::alloc::vec::Vec<ValidatorUpdate>,
613    #[prost(bytes = "vec", tag = "3")]
614    pub app_hash: ::prost::alloc::vec::Vec<u8>,
615}
616#[allow(clippy::derive_partial_eq_without_eq)]
617#[derive(
618    Clone,
619    PartialEq,
620    Eq,
621    ::prost::Message,
622    ::serde::Serialize,
623    ::serde::Deserialize,
624    ::schemars::JsonSchema,
625    CosmwasmExt,
626)]
627#[proto_message(type_url = "/tendermint.abci.ResponseQuery")]
628pub struct ResponseQuery {
629    #[prost(uint32, tag = "1")]
630    #[serde(
631        serialize_with = "crate::serde::as_str::serialize",
632        deserialize_with = "crate::serde::as_str::deserialize"
633    )]
634    pub code: u32,
635    /// bytes data = 2; // use "value" instead.
636    ///
637    /// nondeterministic
638    #[prost(string, tag = "3")]
639    pub log: ::prost::alloc::string::String,
640    /// nondeterministic
641    #[prost(string, tag = "4")]
642    pub info: ::prost::alloc::string::String,
643    #[prost(int64, tag = "5")]
644    #[serde(
645        serialize_with = "crate::serde::as_str::serialize",
646        deserialize_with = "crate::serde::as_str::deserialize"
647    )]
648    pub index: i64,
649    #[prost(bytes = "vec", tag = "6")]
650    pub key: ::prost::alloc::vec::Vec<u8>,
651    #[prost(bytes = "vec", tag = "7")]
652    pub value: ::prost::alloc::vec::Vec<u8>,
653    #[prost(message, optional, tag = "8")]
654    pub proof_ops: ::core::option::Option<super::crypto::ProofOps>,
655    #[prost(int64, tag = "9")]
656    #[serde(
657        serialize_with = "crate::serde::as_str::serialize",
658        deserialize_with = "crate::serde::as_str::deserialize"
659    )]
660    pub height: i64,
661    #[prost(string, tag = "10")]
662    pub codespace: ::prost::alloc::string::String,
663}
664#[allow(clippy::derive_partial_eq_without_eq)]
665#[derive(
666    Clone,
667    PartialEq,
668    Eq,
669    ::prost::Message,
670    ::serde::Serialize,
671    ::serde::Deserialize,
672    ::schemars::JsonSchema,
673    CosmwasmExt,
674)]
675#[proto_message(type_url = "/tendermint.abci.ResponseBeginBlock")]
676pub struct ResponseBeginBlock {
677    #[prost(message, repeated, tag = "1")]
678    pub events: ::prost::alloc::vec::Vec<Event>,
679}
680#[allow(clippy::derive_partial_eq_without_eq)]
681#[derive(
682    Clone,
683    PartialEq,
684    Eq,
685    ::prost::Message,
686    ::serde::Serialize,
687    ::serde::Deserialize,
688    ::schemars::JsonSchema,
689    CosmwasmExt,
690)]
691#[proto_message(type_url = "/tendermint.abci.ResponseCheckTx")]
692pub struct ResponseCheckTx {
693    #[prost(uint32, tag = "1")]
694    #[serde(
695        serialize_with = "crate::serde::as_str::serialize",
696        deserialize_with = "crate::serde::as_str::deserialize"
697    )]
698    pub code: u32,
699    #[prost(bytes = "vec", tag = "2")]
700    pub data: ::prost::alloc::vec::Vec<u8>,
701    /// nondeterministic
702    #[prost(string, tag = "3")]
703    pub log: ::prost::alloc::string::String,
704    /// nondeterministic
705    #[prost(string, tag = "4")]
706    pub info: ::prost::alloc::string::String,
707    #[prost(int64, tag = "5")]
708    #[serde(
709        serialize_with = "crate::serde::as_str::serialize",
710        deserialize_with = "crate::serde::as_str::deserialize"
711    )]
712    pub gas_wanted: i64,
713    #[prost(int64, tag = "6")]
714    #[serde(
715        serialize_with = "crate::serde::as_str::serialize",
716        deserialize_with = "crate::serde::as_str::deserialize"
717    )]
718    pub gas_used: i64,
719    #[prost(message, repeated, tag = "7")]
720    pub events: ::prost::alloc::vec::Vec<Event>,
721    #[prost(string, tag = "8")]
722    pub codespace: ::prost::alloc::string::String,
723    #[prost(string, tag = "9")]
724    pub sender: ::prost::alloc::string::String,
725    #[prost(int64, tag = "10")]
726    #[serde(
727        serialize_with = "crate::serde::as_str::serialize",
728        deserialize_with = "crate::serde::as_str::deserialize"
729    )]
730    pub priority: i64,
731    /// mempool_error is set by CometBFT.
732    /// ABCI applictions creating a ResponseCheckTX should not set mempool_error.
733    #[prost(string, tag = "11")]
734    pub mempool_error: ::prost::alloc::string::String,
735}
736#[allow(clippy::derive_partial_eq_without_eq)]
737#[derive(
738    Clone,
739    PartialEq,
740    Eq,
741    ::prost::Message,
742    ::serde::Serialize,
743    ::serde::Deserialize,
744    ::schemars::JsonSchema,
745    CosmwasmExt,
746)]
747#[proto_message(type_url = "/tendermint.abci.ResponseDeliverTx")]
748pub struct ResponseDeliverTx {
749    #[prost(uint32, tag = "1")]
750    #[serde(
751        serialize_with = "crate::serde::as_str::serialize",
752        deserialize_with = "crate::serde::as_str::deserialize"
753    )]
754    pub code: u32,
755    #[prost(bytes = "vec", tag = "2")]
756    pub data: ::prost::alloc::vec::Vec<u8>,
757    /// nondeterministic
758    #[prost(string, tag = "3")]
759    pub log: ::prost::alloc::string::String,
760    /// nondeterministic
761    #[prost(string, tag = "4")]
762    pub info: ::prost::alloc::string::String,
763    #[prost(int64, tag = "5")]
764    #[serde(
765        serialize_with = "crate::serde::as_str::serialize",
766        deserialize_with = "crate::serde::as_str::deserialize"
767    )]
768    pub gas_wanted: i64,
769    #[prost(int64, tag = "6")]
770    #[serde(
771        serialize_with = "crate::serde::as_str::serialize",
772        deserialize_with = "crate::serde::as_str::deserialize"
773    )]
774    pub gas_used: i64,
775    /// nondeterministic
776    #[prost(message, repeated, tag = "7")]
777    pub events: ::prost::alloc::vec::Vec<Event>,
778    #[prost(string, tag = "8")]
779    pub codespace: ::prost::alloc::string::String,
780}
781#[allow(clippy::derive_partial_eq_without_eq)]
782#[derive(
783    Clone,
784    PartialEq,
785    Eq,
786    ::prost::Message,
787    ::serde::Serialize,
788    ::serde::Deserialize,
789    ::schemars::JsonSchema,
790    CosmwasmExt,
791)]
792#[proto_message(type_url = "/tendermint.abci.ResponseEndBlock")]
793pub struct ResponseEndBlock {
794    #[prost(message, repeated, tag = "1")]
795    pub validator_updates: ::prost::alloc::vec::Vec<ValidatorUpdate>,
796    #[prost(message, optional, tag = "2")]
797    pub consensus_param_updates: ::core::option::Option<super::types::ConsensusParams>,
798    #[prost(message, repeated, tag = "3")]
799    pub events: ::prost::alloc::vec::Vec<Event>,
800}
801#[allow(clippy::derive_partial_eq_without_eq)]
802#[derive(
803    Clone,
804    PartialEq,
805    Eq,
806    ::prost::Message,
807    ::serde::Serialize,
808    ::serde::Deserialize,
809    ::schemars::JsonSchema,
810    CosmwasmExt,
811)]
812#[proto_message(type_url = "/tendermint.abci.ResponseCommit")]
813pub struct ResponseCommit {
814    /// reserve 1
815    #[prost(bytes = "vec", tag = "2")]
816    pub data: ::prost::alloc::vec::Vec<u8>,
817    #[prost(int64, tag = "3")]
818    #[serde(
819        serialize_with = "crate::serde::as_str::serialize",
820        deserialize_with = "crate::serde::as_str::deserialize"
821    )]
822    pub retain_height: i64,
823}
824#[allow(clippy::derive_partial_eq_without_eq)]
825#[derive(
826    Clone,
827    PartialEq,
828    Eq,
829    ::prost::Message,
830    ::serde::Serialize,
831    ::serde::Deserialize,
832    ::schemars::JsonSchema,
833    CosmwasmExt,
834)]
835#[proto_message(type_url = "/tendermint.abci.ResponseListSnapshots")]
836pub struct ResponseListSnapshots {
837    #[prost(message, repeated, tag = "1")]
838    pub snapshots: ::prost::alloc::vec::Vec<Snapshot>,
839}
840#[allow(clippy::derive_partial_eq_without_eq)]
841#[derive(
842    Clone,
843    PartialEq,
844    Eq,
845    ::prost::Message,
846    ::serde::Serialize,
847    ::serde::Deserialize,
848    ::schemars::JsonSchema,
849    CosmwasmExt,
850)]
851#[proto_message(type_url = "/tendermint.abci.ResponseOfferSnapshot")]
852pub struct ResponseOfferSnapshot {
853    #[prost(enumeration = "response_offer_snapshot::Result", tag = "1")]
854    #[serde(
855        serialize_with = "response_offer_snapshot::result_serde::serialize",
856        deserialize_with = "response_offer_snapshot::result_serde::deserialize"
857    )]
858    pub result: i32,
859}
860/// Nested message and enum types in `ResponseOfferSnapshot`.
861pub mod response_offer_snapshot {
862    use persistence_std_derive::CosmwasmExt;
863    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
864    #[repr(i32)]
865    #[derive(::schemars::JsonSchema)]
866    pub enum Result {
867        /// Unknown result, abort all snapshot restoration
868        Unknown = 0,
869        /// Snapshot accepted, apply chunks
870        Accept = 1,
871        /// Abort all snapshot restoration
872        Abort = 2,
873        /// Reject this specific snapshot, try others
874        Reject = 3,
875        /// Reject all snapshots of this format, try others
876        RejectFormat = 4,
877        /// Reject all snapshots from the sender(s), try others
878        RejectSender = 5,
879    }
880    pub mod result_serde {
881        use super::Result;
882        use serde::{Deserialize, Deserializer, Serializer};
883        pub fn deserialize<'de, T, D>(deserializer: D) -> std::result::Result<T, D::Error>
884        where
885            T: From<Result>,
886            D: Deserializer<'de>,
887        {
888            let s = String::deserialize(deserializer)?;
889            let enum_value = Result::from_str_name(&s).unwrap();
890            let int_value: T = enum_value.into();
891            return Ok(int_value);
892        }
893        pub fn serialize<S>(value: &i32, serializer: S) -> std::result::Result<S::Ok, S::Error>
894        where
895            S: Serializer,
896        {
897            let s: Result = Result::from_i32(*value).unwrap();
898            serializer.serialize_str(s.as_str_name())
899        }
900    }
901    impl Result {
902        /// String value of the enum field names used in the ProtoBuf definition.
903        ///
904        /// The values are not transformed in any way and thus are considered stable
905        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
906        pub fn as_str_name(&self) -> &'static str {
907            match self {
908                Result::Unknown => "UNKNOWN",
909                Result::Accept => "ACCEPT",
910                Result::Abort => "ABORT",
911                Result::Reject => "REJECT",
912                Result::RejectFormat => "REJECT_FORMAT",
913                Result::RejectSender => "REJECT_SENDER",
914            }
915        }
916        /// Creates an enum from field names used in the ProtoBuf definition.
917        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
918            match value {
919                "UNKNOWN" => Some(Self::Unknown),
920                "ACCEPT" => Some(Self::Accept),
921                "ABORT" => Some(Self::Abort),
922                "REJECT" => Some(Self::Reject),
923                "REJECT_FORMAT" => Some(Self::RejectFormat),
924                "REJECT_SENDER" => Some(Self::RejectSender),
925                _ => None,
926            }
927        }
928    }
929}
930#[allow(clippy::derive_partial_eq_without_eq)]
931#[derive(
932    Clone,
933    PartialEq,
934    Eq,
935    ::prost::Message,
936    ::serde::Serialize,
937    ::serde::Deserialize,
938    ::schemars::JsonSchema,
939    CosmwasmExt,
940)]
941#[proto_message(type_url = "/tendermint.abci.ResponseLoadSnapshotChunk")]
942pub struct ResponseLoadSnapshotChunk {
943    #[prost(bytes = "vec", tag = "1")]
944    pub chunk: ::prost::alloc::vec::Vec<u8>,
945}
946#[allow(clippy::derive_partial_eq_without_eq)]
947#[derive(
948    Clone,
949    PartialEq,
950    Eq,
951    ::prost::Message,
952    ::serde::Serialize,
953    ::serde::Deserialize,
954    ::schemars::JsonSchema,
955    CosmwasmExt,
956)]
957#[proto_message(type_url = "/tendermint.abci.ResponseApplySnapshotChunk")]
958pub struct ResponseApplySnapshotChunk {
959    #[prost(enumeration = "response_apply_snapshot_chunk::Result", tag = "1")]
960    #[serde(
961        serialize_with = "response_apply_snapshot_chunk::result_serde::serialize",
962        deserialize_with = "response_apply_snapshot_chunk::result_serde::deserialize"
963    )]
964    pub result: i32,
965    /// Chunks to refetch and reapply
966    #[prost(uint32, repeated, tag = "2")]
967    pub refetch_chunks: ::prost::alloc::vec::Vec<u32>,
968    /// Chunk senders to reject and ban
969    #[prost(string, repeated, tag = "3")]
970    pub reject_senders: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
971}
972/// Nested message and enum types in `ResponseApplySnapshotChunk`.
973pub mod response_apply_snapshot_chunk {
974    use persistence_std_derive::CosmwasmExt;
975    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
976    #[repr(i32)]
977    #[derive(::schemars::JsonSchema)]
978    pub enum Result {
979        /// Unknown result, abort all snapshot restoration
980        Unknown = 0,
981        /// Chunk successfully accepted
982        Accept = 1,
983        /// Abort all snapshot restoration
984        Abort = 2,
985        /// Retry chunk (combine with refetch and reject)
986        Retry = 3,
987        /// Retry snapshot (combine with refetch and reject)
988        RetrySnapshot = 4,
989        /// Reject this snapshot, try others
990        RejectSnapshot = 5,
991    }
992    pub mod result_serde {
993        use super::Result;
994        use serde::{Deserialize, Deserializer, Serializer};
995        pub fn deserialize<'de, T, D>(deserializer: D) -> std::result::Result<T, D::Error>
996        where
997            T: From<Result>,
998            D: Deserializer<'de>,
999        {
1000            let s = String::deserialize(deserializer)?;
1001            let enum_value = Result::from_str_name(&s).unwrap();
1002            let int_value: T = enum_value.into();
1003            return Ok(int_value);
1004        }
1005        pub fn serialize<S>(value: &i32, serializer: S) -> std::result::Result<S::Ok, S::Error>
1006        where
1007            S: Serializer,
1008        {
1009            let s: Result = Result::from_i32(*value).unwrap();
1010            serializer.serialize_str(s.as_str_name())
1011        }
1012    }
1013    impl Result {
1014        /// String value of the enum field names used in the ProtoBuf definition.
1015        ///
1016        /// The values are not transformed in any way and thus are considered stable
1017        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1018        pub fn as_str_name(&self) -> &'static str {
1019            match self {
1020                Result::Unknown => "UNKNOWN",
1021                Result::Accept => "ACCEPT",
1022                Result::Abort => "ABORT",
1023                Result::Retry => "RETRY",
1024                Result::RetrySnapshot => "RETRY_SNAPSHOT",
1025                Result::RejectSnapshot => "REJECT_SNAPSHOT",
1026            }
1027        }
1028        /// Creates an enum from field names used in the ProtoBuf definition.
1029        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1030            match value {
1031                "UNKNOWN" => Some(Self::Unknown),
1032                "ACCEPT" => Some(Self::Accept),
1033                "ABORT" => Some(Self::Abort),
1034                "RETRY" => Some(Self::Retry),
1035                "RETRY_SNAPSHOT" => Some(Self::RetrySnapshot),
1036                "REJECT_SNAPSHOT" => Some(Self::RejectSnapshot),
1037                _ => None,
1038            }
1039        }
1040    }
1041}
1042#[allow(clippy::derive_partial_eq_without_eq)]
1043#[derive(
1044    Clone,
1045    PartialEq,
1046    Eq,
1047    ::prost::Message,
1048    ::serde::Serialize,
1049    ::serde::Deserialize,
1050    ::schemars::JsonSchema,
1051    CosmwasmExt,
1052)]
1053#[proto_message(type_url = "/tendermint.abci.ResponsePrepareProposal")]
1054pub struct ResponsePrepareProposal {
1055    #[prost(bytes = "vec", repeated, tag = "1")]
1056    pub txs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
1057}
1058#[allow(clippy::derive_partial_eq_without_eq)]
1059#[derive(
1060    Clone,
1061    PartialEq,
1062    Eq,
1063    ::prost::Message,
1064    ::serde::Serialize,
1065    ::serde::Deserialize,
1066    ::schemars::JsonSchema,
1067    CosmwasmExt,
1068)]
1069#[proto_message(type_url = "/tendermint.abci.ResponseProcessProposal")]
1070pub struct ResponseProcessProposal {
1071    #[prost(enumeration = "response_process_proposal::ProposalStatus", tag = "1")]
1072    #[serde(
1073        serialize_with = "response_process_proposal::proposal_status_serde::serialize",
1074        deserialize_with = "response_process_proposal::proposal_status_serde::deserialize"
1075    )]
1076    pub status: i32,
1077}
1078/// Nested message and enum types in `ResponseProcessProposal`.
1079pub mod response_process_proposal {
1080    use persistence_std_derive::CosmwasmExt;
1081    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1082    #[repr(i32)]
1083    #[derive(::schemars::JsonSchema)]
1084    pub enum ProposalStatus {
1085        Unknown = 0,
1086        Accept = 1,
1087        Reject = 2,
1088    }
1089    pub mod proposal_status_serde {
1090        use super::ProposalStatus;
1091        use serde::{Deserialize, Deserializer, Serializer};
1092        pub fn deserialize<'de, T, D>(deserializer: D) -> std::result::Result<T, D::Error>
1093        where
1094            T: From<ProposalStatus>,
1095            D: Deserializer<'de>,
1096        {
1097            let s = String::deserialize(deserializer)?;
1098            let enum_value = ProposalStatus::from_str_name(&s).unwrap();
1099            let int_value: T = enum_value.into();
1100            return Ok(int_value);
1101        }
1102        pub fn serialize<S>(value: &i32, serializer: S) -> std::result::Result<S::Ok, S::Error>
1103        where
1104            S: Serializer,
1105        {
1106            let s: ProposalStatus = ProposalStatus::from_i32(*value).unwrap();
1107            serializer.serialize_str(s.as_str_name())
1108        }
1109    }
1110    impl ProposalStatus {
1111        /// String value of the enum field names used in the ProtoBuf definition.
1112        ///
1113        /// The values are not transformed in any way and thus are considered stable
1114        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1115        pub fn as_str_name(&self) -> &'static str {
1116            match self {
1117                ProposalStatus::Unknown => "UNKNOWN",
1118                ProposalStatus::Accept => "ACCEPT",
1119                ProposalStatus::Reject => "REJECT",
1120            }
1121        }
1122        /// Creates an enum from field names used in the ProtoBuf definition.
1123        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1124            match value {
1125                "UNKNOWN" => Some(Self::Unknown),
1126                "ACCEPT" => Some(Self::Accept),
1127                "REJECT" => Some(Self::Reject),
1128                _ => None,
1129            }
1130        }
1131    }
1132}
1133#[allow(clippy::derive_partial_eq_without_eq)]
1134#[derive(
1135    Clone,
1136    PartialEq,
1137    Eq,
1138    ::prost::Message,
1139    ::serde::Serialize,
1140    ::serde::Deserialize,
1141    ::schemars::JsonSchema,
1142    CosmwasmExt,
1143)]
1144#[proto_message(type_url = "/tendermint.abci.CommitInfo")]
1145pub struct CommitInfo {
1146    #[prost(int32, tag = "1")]
1147    #[serde(
1148        serialize_with = "crate::serde::as_str::serialize",
1149        deserialize_with = "crate::serde::as_str::deserialize"
1150    )]
1151    pub round: i32,
1152    #[prost(message, repeated, tag = "2")]
1153    pub votes: ::prost::alloc::vec::Vec<VoteInfo>,
1154}
1155#[allow(clippy::derive_partial_eq_without_eq)]
1156#[derive(
1157    Clone,
1158    PartialEq,
1159    Eq,
1160    ::prost::Message,
1161    ::serde::Serialize,
1162    ::serde::Deserialize,
1163    ::schemars::JsonSchema,
1164    CosmwasmExt,
1165)]
1166#[proto_message(type_url = "/tendermint.abci.ExtendedCommitInfo")]
1167pub struct ExtendedCommitInfo {
1168    /// The round at which the block proposer decided in the previous height.
1169    #[prost(int32, tag = "1")]
1170    #[serde(
1171        serialize_with = "crate::serde::as_str::serialize",
1172        deserialize_with = "crate::serde::as_str::deserialize"
1173    )]
1174    pub round: i32,
1175    /// List of validators' addresses in the last validator set with their voting
1176    /// information, including vote extensions.
1177    #[prost(message, repeated, tag = "2")]
1178    pub votes: ::prost::alloc::vec::Vec<ExtendedVoteInfo>,
1179}
1180/// Event allows application developers to attach additional information to
1181/// ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
1182/// Later, transactions may be queried using these events.
1183#[allow(clippy::derive_partial_eq_without_eq)]
1184#[derive(
1185    Clone,
1186    PartialEq,
1187    Eq,
1188    ::prost::Message,
1189    ::serde::Serialize,
1190    ::serde::Deserialize,
1191    ::schemars::JsonSchema,
1192    CosmwasmExt,
1193)]
1194#[proto_message(type_url = "/tendermint.abci.Event")]
1195pub struct Event {
1196    #[prost(string, tag = "1")]
1197    pub r#type: ::prost::alloc::string::String,
1198    #[prost(message, repeated, tag = "2")]
1199    pub attributes: ::prost::alloc::vec::Vec<EventAttribute>,
1200}
1201/// EventAttribute is a single key-value pair, associated with an event.
1202#[allow(clippy::derive_partial_eq_without_eq)]
1203#[derive(
1204    Clone,
1205    PartialEq,
1206    Eq,
1207    ::prost::Message,
1208    ::serde::Serialize,
1209    ::serde::Deserialize,
1210    ::schemars::JsonSchema,
1211    CosmwasmExt,
1212)]
1213#[proto_message(type_url = "/tendermint.abci.EventAttribute")]
1214pub struct EventAttribute {
1215    #[prost(string, tag = "1")]
1216    pub key: ::prost::alloc::string::String,
1217    #[prost(string, tag = "2")]
1218    pub value: ::prost::alloc::string::String,
1219    /// nondeterministic
1220    #[prost(bool, tag = "3")]
1221    pub index: bool,
1222}
1223/// TxResult contains results of executing the transaction.
1224///
1225/// One usage is indexing transaction results.
1226#[allow(clippy::derive_partial_eq_without_eq)]
1227#[derive(
1228    Clone,
1229    PartialEq,
1230    Eq,
1231    ::prost::Message,
1232    ::serde::Serialize,
1233    ::serde::Deserialize,
1234    ::schemars::JsonSchema,
1235    CosmwasmExt,
1236)]
1237#[proto_message(type_url = "/tendermint.abci.TxResult")]
1238pub struct TxResult {
1239    #[prost(int64, tag = "1")]
1240    #[serde(
1241        serialize_with = "crate::serde::as_str::serialize",
1242        deserialize_with = "crate::serde::as_str::deserialize"
1243    )]
1244    pub height: i64,
1245    #[prost(uint32, tag = "2")]
1246    #[serde(
1247        serialize_with = "crate::serde::as_str::serialize",
1248        deserialize_with = "crate::serde::as_str::deserialize"
1249    )]
1250    pub index: u32,
1251    #[prost(bytes = "vec", tag = "3")]
1252    pub tx: ::prost::alloc::vec::Vec<u8>,
1253    #[prost(message, optional, tag = "4")]
1254    pub result: ::core::option::Option<ResponseDeliverTx>,
1255}
1256/// Validator
1257#[allow(clippy::derive_partial_eq_without_eq)]
1258#[derive(
1259    Clone,
1260    PartialEq,
1261    Eq,
1262    ::prost::Message,
1263    ::serde::Serialize,
1264    ::serde::Deserialize,
1265    ::schemars::JsonSchema,
1266    CosmwasmExt,
1267)]
1268#[proto_message(type_url = "/tendermint.abci.Validator")]
1269pub struct Validator {
1270    /// The first 20 bytes of SHA256(public key)
1271    #[prost(bytes = "vec", tag = "1")]
1272    pub address: ::prost::alloc::vec::Vec<u8>,
1273    /// PubKey pub_key = 2 \[(gogoproto.nullable)=false\];
1274    ///
1275    /// The voting power
1276    #[prost(int64, tag = "3")]
1277    #[serde(
1278        serialize_with = "crate::serde::as_str::serialize",
1279        deserialize_with = "crate::serde::as_str::deserialize"
1280    )]
1281    pub power: i64,
1282}
1283/// ValidatorUpdate
1284#[allow(clippy::derive_partial_eq_without_eq)]
1285#[derive(
1286    Clone,
1287    PartialEq,
1288    Eq,
1289    ::prost::Message,
1290    ::serde::Serialize,
1291    ::serde::Deserialize,
1292    ::schemars::JsonSchema,
1293    CosmwasmExt,
1294)]
1295#[proto_message(type_url = "/tendermint.abci.ValidatorUpdate")]
1296pub struct ValidatorUpdate {
1297    #[prost(message, optional, tag = "1")]
1298    pub pub_key: ::core::option::Option<super::crypto::PublicKey>,
1299    #[prost(int64, tag = "2")]
1300    #[serde(
1301        serialize_with = "crate::serde::as_str::serialize",
1302        deserialize_with = "crate::serde::as_str::deserialize"
1303    )]
1304    pub power: i64,
1305}
1306/// VoteInfo
1307#[allow(clippy::derive_partial_eq_without_eq)]
1308#[derive(
1309    Clone,
1310    PartialEq,
1311    Eq,
1312    ::prost::Message,
1313    ::serde::Serialize,
1314    ::serde::Deserialize,
1315    ::schemars::JsonSchema,
1316    CosmwasmExt,
1317)]
1318#[proto_message(type_url = "/tendermint.abci.VoteInfo")]
1319pub struct VoteInfo {
1320    #[prost(message, optional, tag = "1")]
1321    pub validator: ::core::option::Option<Validator>,
1322    #[prost(bool, tag = "2")]
1323    pub signed_last_block: bool,
1324}
1325#[allow(clippy::derive_partial_eq_without_eq)]
1326#[derive(
1327    Clone,
1328    PartialEq,
1329    Eq,
1330    ::prost::Message,
1331    ::serde::Serialize,
1332    ::serde::Deserialize,
1333    ::schemars::JsonSchema,
1334    CosmwasmExt,
1335)]
1336#[proto_message(type_url = "/tendermint.abci.ExtendedVoteInfo")]
1337pub struct ExtendedVoteInfo {
1338    #[prost(message, optional, tag = "1")]
1339    pub validator: ::core::option::Option<Validator>,
1340    #[prost(bool, tag = "2")]
1341    pub signed_last_block: bool,
1342    /// Reserved for future use
1343    #[prost(bytes = "vec", tag = "3")]
1344    pub vote_extension: ::prost::alloc::vec::Vec<u8>,
1345}
1346#[allow(clippy::derive_partial_eq_without_eq)]
1347#[derive(
1348    Clone,
1349    PartialEq,
1350    Eq,
1351    ::prost::Message,
1352    ::serde::Serialize,
1353    ::serde::Deserialize,
1354    ::schemars::JsonSchema,
1355    CosmwasmExt,
1356)]
1357#[proto_message(type_url = "/tendermint.abci.Misbehavior")]
1358pub struct Misbehavior {
1359    #[prost(enumeration = "MisbehaviorType", tag = "1")]
1360    #[serde(
1361        serialize_with = "misbehavior_type_serde::serialize",
1362        deserialize_with = "misbehavior_type_serde::deserialize"
1363    )]
1364    pub r#type: i32,
1365    /// The offending validator
1366    #[prost(message, optional, tag = "2")]
1367    pub validator: ::core::option::Option<Validator>,
1368    /// The height when the offense occurred
1369    #[prost(int64, tag = "3")]
1370    #[serde(
1371        serialize_with = "crate::serde::as_str::serialize",
1372        deserialize_with = "crate::serde::as_str::deserialize"
1373    )]
1374    pub height: i64,
1375    /// The corresponding time where the offense occurred
1376    #[prost(message, optional, tag = "4")]
1377    pub time: ::core::option::Option<crate::shim::Timestamp>,
1378    /// Total voting power of the validator set in case the ABCI application does
1379    /// not store historical validators.
1380    /// <https://github.com/tendermint/tendermint/issues/4581>
1381    #[prost(int64, tag = "5")]
1382    #[serde(
1383        serialize_with = "crate::serde::as_str::serialize",
1384        deserialize_with = "crate::serde::as_str::deserialize"
1385    )]
1386    pub total_voting_power: i64,
1387}
1388#[allow(clippy::derive_partial_eq_without_eq)]
1389#[derive(
1390    Clone,
1391    PartialEq,
1392    Eq,
1393    ::prost::Message,
1394    ::serde::Serialize,
1395    ::serde::Deserialize,
1396    ::schemars::JsonSchema,
1397    CosmwasmExt,
1398)]
1399#[proto_message(type_url = "/tendermint.abci.Snapshot")]
1400pub struct Snapshot {
1401    /// The height at which the snapshot was taken
1402    #[prost(uint64, tag = "1")]
1403    #[serde(
1404        serialize_with = "crate::serde::as_str::serialize",
1405        deserialize_with = "crate::serde::as_str::deserialize"
1406    )]
1407    pub height: u64,
1408    /// The application-specific snapshot format
1409    #[prost(uint32, tag = "2")]
1410    #[serde(
1411        serialize_with = "crate::serde::as_str::serialize",
1412        deserialize_with = "crate::serde::as_str::deserialize"
1413    )]
1414    pub format: u32,
1415    /// Number of chunks in the snapshot
1416    #[prost(uint32, tag = "3")]
1417    #[serde(
1418        serialize_with = "crate::serde::as_str::serialize",
1419        deserialize_with = "crate::serde::as_str::deserialize"
1420    )]
1421    pub chunks: u32,
1422    /// Arbitrary snapshot hash, equal only if identical
1423    #[prost(bytes = "vec", tag = "4")]
1424    pub hash: ::prost::alloc::vec::Vec<u8>,
1425    /// Arbitrary application metadata
1426    #[prost(bytes = "vec", tag = "5")]
1427    pub metadata: ::prost::alloc::vec::Vec<u8>,
1428}
1429#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1430#[repr(i32)]
1431#[derive(::schemars::JsonSchema)]
1432pub enum CheckTxType {
1433    New = 0,
1434    Recheck = 1,
1435}
1436pub mod check_tx_type_serde {
1437    use super::CheckTxType;
1438    use serde::{Deserialize, Deserializer, Serializer};
1439    pub fn deserialize<'de, T, D>(deserializer: D) -> std::result::Result<T, D::Error>
1440    where
1441        T: From<CheckTxType>,
1442        D: Deserializer<'de>,
1443    {
1444        let s = String::deserialize(deserializer)?;
1445        let enum_value = CheckTxType::from_str_name(&s).unwrap();
1446        let int_value: T = enum_value.into();
1447        return Ok(int_value);
1448    }
1449    pub fn serialize<S>(value: &i32, serializer: S) -> std::result::Result<S::Ok, S::Error>
1450    where
1451        S: Serializer,
1452    {
1453        let s: CheckTxType = CheckTxType::from_i32(*value).unwrap();
1454        serializer.serialize_str(s.as_str_name())
1455    }
1456}
1457impl CheckTxType {
1458    /// String value of the enum field names used in the ProtoBuf definition.
1459    ///
1460    /// The values are not transformed in any way and thus are considered stable
1461    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1462    pub fn as_str_name(&self) -> &'static str {
1463        match self {
1464            CheckTxType::New => "NEW",
1465            CheckTxType::Recheck => "RECHECK",
1466        }
1467    }
1468    /// Creates an enum from field names used in the ProtoBuf definition.
1469    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1470        match value {
1471            "NEW" => Some(Self::New),
1472            "RECHECK" => Some(Self::Recheck),
1473            _ => None,
1474        }
1475    }
1476}
1477#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1478#[repr(i32)]
1479#[derive(::schemars::JsonSchema)]
1480pub enum MisbehaviorType {
1481    Unknown = 0,
1482    DuplicateVote = 1,
1483    LightClientAttack = 2,
1484}
1485pub mod misbehavior_type_serde {
1486    use super::MisbehaviorType;
1487    use serde::{Deserialize, Deserializer, Serializer};
1488    pub fn deserialize<'de, T, D>(deserializer: D) -> std::result::Result<T, D::Error>
1489    where
1490        T: From<MisbehaviorType>,
1491        D: Deserializer<'de>,
1492    {
1493        let s = String::deserialize(deserializer)?;
1494        let enum_value = MisbehaviorType::from_str_name(&s).unwrap();
1495        let int_value: T = enum_value.into();
1496        return Ok(int_value);
1497    }
1498    pub fn serialize<S>(value: &i32, serializer: S) -> std::result::Result<S::Ok, S::Error>
1499    where
1500        S: Serializer,
1501    {
1502        let s: MisbehaviorType = MisbehaviorType::from_i32(*value).unwrap();
1503        serializer.serialize_str(s.as_str_name())
1504    }
1505}
1506impl MisbehaviorType {
1507    /// String value of the enum field names used in the ProtoBuf definition.
1508    ///
1509    /// The values are not transformed in any way and thus are considered stable
1510    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1511    pub fn as_str_name(&self) -> &'static str {
1512        match self {
1513            MisbehaviorType::Unknown => "UNKNOWN",
1514            MisbehaviorType::DuplicateVote => "DUPLICATE_VOTE",
1515            MisbehaviorType::LightClientAttack => "LIGHT_CLIENT_ATTACK",
1516        }
1517    }
1518    /// Creates an enum from field names used in the ProtoBuf definition.
1519    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1520        match value {
1521            "UNKNOWN" => Some(Self::Unknown),
1522            "DUPLICATE_VOTE" => Some(Self::DuplicateVote),
1523            "LIGHT_CLIENT_ATTACK" => Some(Self::LightClientAttack),
1524            _ => None,
1525        }
1526    }
1527}
persistence_std/types/tendermint/abci.rs

persistence_std/types/tendermint/
abci.rs
