tendermint/v0_37/abci/
response.rs

1pub use crate::abci::response::{
2    ApplySnapshotChunk, BeginBlock, CheckTx, Commit, DeliverTx, Echo, EndBlock, Exception, Info,
3    InitChain, ListSnapshots, LoadSnapshotChunk, OfferSnapshot, PrepareProposal, ProcessProposal,
4    Query,
5};
6use crate::Error;
7
8/// All possible ABCI responses for this protocol version.
9#[derive(Clone, PartialEq, Eq, Debug)]
10pub enum Response {
11    #[doc = include_str!("../../abci/doc/response-exception.md")]
12    Exception(Exception),
13    #[doc = include_str!("../../abci/doc/response-echo.md")]
14    Echo(Echo),
15    #[doc = include_str!("../../abci/doc/response-flush.md")]
16    Flush,
17    #[doc = include_str!("../../abci/doc/response-info.md")]
18    Info(Info),
19    #[doc = include_str!("../../abci/doc/response-initchain.md")]
20    InitChain(InitChain),
21    #[doc = include_str!("../../abci/doc/response-query.md")]
22    Query(Query),
23    #[doc = include_str!("../../abci/doc/response-beginblock.md")]
24    BeginBlock(BeginBlock),
25    #[doc = include_str!("../../abci/doc/response-checktx.md")]
26    CheckTx(CheckTx),
27    #[doc = include_str!("../../abci/doc/response-delivertx.md")]
28    DeliverTx(DeliverTx),
29    #[doc = include_str!("../../abci/doc/response-endblock.md")]
30    EndBlock(EndBlock),
31    #[doc = include_str!("../../abci/doc/response-commit.md")]
32    Commit(Commit),
33    #[doc = include_str!("../../abci/doc/response-listsnapshots.md")]
34    ListSnapshots(ListSnapshots),
35    #[doc = include_str!("../../abci/doc/response-offersnapshot.md")]
36    OfferSnapshot(OfferSnapshot),
37    #[doc = include_str!("../../abci/doc/response-loadsnapshotchunk.md")]
38    LoadSnapshotChunk(LoadSnapshotChunk),
39    #[doc = include_str!("../../abci/doc/response-applysnapshotchunk.md")]
40    ApplySnapshotChunk(ApplySnapshotChunk),
41    #[doc = include_str!("../../abci/doc/response-prepareproposal.md")]
42    PrepareProposal(PrepareProposal),
43    #[doc = include_str!("../../abci/doc/response-processproposal.md")]
44    ProcessProposal(ProcessProposal),
45}
46
47/// The consensus category of ABCI responses.
48#[derive(Clone, PartialEq, Eq, Debug)]
49pub enum ConsensusResponse {
50    #[doc = include_str!("../../abci/doc/response-initchain.md")]
51    InitChain(InitChain),
52    #[doc = include_str!("../../abci/doc/response-prepareproposal.md")]
53    PrepareProposal(PrepareProposal),
54    #[doc = include_str!("../../abci/doc/response-processproposal.md")]
55    ProcessProposal(ProcessProposal),
56    #[doc = include_str!("../../abci/doc/response-beginblock.md")]
57    BeginBlock(BeginBlock),
58    #[doc = include_str!("../../abci/doc/response-delivertx.md")]
59    DeliverTx(DeliverTx),
60    #[doc = include_str!("../../abci/doc/response-endblock.md")]
61    EndBlock(EndBlock),
62    #[doc = include_str!("../../abci/doc/response-commit.md")]
63    Commit(Commit),
64}
65
66/// The mempool category of ABCI responses.
67#[derive(Clone, PartialEq, Eq, Debug)]
68pub enum MempoolResponse {
69    #[doc = include_str!("../../abci/doc/response-checktx.md")]
70    CheckTx(CheckTx),
71}
72
73/// The info category of ABCI responses.
74#[derive(Clone, PartialEq, Eq, Debug)]
75pub enum InfoResponse {
76    #[doc = include_str!("../../abci/doc/response-echo.md")]
77    Echo(Echo),
78    #[doc = include_str!("../../abci/doc/response-info.md")]
79    Info(Info),
80    #[doc = include_str!("../../abci/doc/response-query.md")]
81    Query(Query),
82}
83
84/// The snapshot category of ABCI responses.
85#[derive(Clone, PartialEq, Eq, Debug)]
86pub enum SnapshotResponse {
87    #[doc = include_str!("../../abci/doc/response-listsnapshots.md")]
88    ListSnapshots(ListSnapshots),
89    #[doc = include_str!("../../abci/doc/response-offersnapshot.md")]
90    OfferSnapshot(OfferSnapshot),
91    #[doc = include_str!("../../abci/doc/response-loadsnapshotchunk.md")]
92    LoadSnapshotChunk(LoadSnapshotChunk),
93    #[doc = include_str!("../../abci/doc/response-applysnapshotchunk.md")]
94    ApplySnapshotChunk(ApplySnapshotChunk),
95}
96
97impl From<ConsensusResponse> for Response {
98    fn from(req: ConsensusResponse) -> Self {
99        match req {
100            ConsensusResponse::InitChain(x) => Self::InitChain(x),
101            ConsensusResponse::PrepareProposal(x) => Self::PrepareProposal(x),
102            ConsensusResponse::ProcessProposal(x) => Self::ProcessProposal(x),
103            ConsensusResponse::BeginBlock(x) => Self::BeginBlock(x),
104            ConsensusResponse::DeliverTx(x) => Self::DeliverTx(x),
105            ConsensusResponse::EndBlock(x) => Self::EndBlock(x),
106            ConsensusResponse::Commit(x) => Self::Commit(x),
107        }
108    }
109}
110
111impl TryFrom<Response> for ConsensusResponse {
112    type Error = Error;
113    fn try_from(req: Response) -> Result<Self, Self::Error> {
114        match req {
115            Response::InitChain(x) => Ok(Self::InitChain(x)),
116            Response::PrepareProposal(x) => Ok(Self::PrepareProposal(x)),
117            Response::ProcessProposal(x) => Ok(Self::ProcessProposal(x)),
118            Response::BeginBlock(x) => Ok(Self::BeginBlock(x)),
119            Response::DeliverTx(x) => Ok(Self::DeliverTx(x)),
120            Response::EndBlock(x) => Ok(Self::EndBlock(x)),
121            Response::Commit(x) => Ok(Self::Commit(x)),
122            _ => Err(Error::invalid_abci_response_type()),
123        }
124    }
125}
126
127impl From<MempoolResponse> for Response {
128    fn from(req: MempoolResponse) -> Self {
129        match req {
130            MempoolResponse::CheckTx(x) => Self::CheckTx(x),
131        }
132    }
133}
134
135impl TryFrom<Response> for MempoolResponse {
136    type Error = Error;
137    fn try_from(req: Response) -> Result<Self, Self::Error> {
138        match req {
139            Response::CheckTx(x) => Ok(Self::CheckTx(x)),
140            _ => Err(Error::invalid_abci_response_type()),
141        }
142    }
143}
144
145impl From<InfoResponse> for Response {
146    fn from(req: InfoResponse) -> Self {
147        match req {
148            InfoResponse::Echo(x) => Self::Echo(x),
149            InfoResponse::Info(x) => Self::Info(x),
150            InfoResponse::Query(x) => Self::Query(x),
151        }
152    }
153}
154
155impl TryFrom<Response> for InfoResponse {
156    type Error = Error;
157    fn try_from(req: Response) -> Result<Self, Self::Error> {
158        match req {
159            Response::Echo(x) => Ok(Self::Echo(x)),
160            Response::Info(x) => Ok(Self::Info(x)),
161            Response::Query(x) => Ok(Self::Query(x)),
162            _ => Err(Error::invalid_abci_response_type()),
163        }
164    }
165}
166
167impl From<SnapshotResponse> for Response {
168    fn from(req: SnapshotResponse) -> Self {
169        match req {
170            SnapshotResponse::ListSnapshots(x) => Self::ListSnapshots(x),
171            SnapshotResponse::OfferSnapshot(x) => Self::OfferSnapshot(x),
172            SnapshotResponse::LoadSnapshotChunk(x) => Self::LoadSnapshotChunk(x),
173            SnapshotResponse::ApplySnapshotChunk(x) => Self::ApplySnapshotChunk(x),
174        }
175    }
176}
177
178impl TryFrom<Response> for SnapshotResponse {
179    type Error = Error;
180    fn try_from(req: Response) -> Result<Self, Self::Error> {
181        match req {
182            Response::ListSnapshots(x) => Ok(Self::ListSnapshots(x)),
183            Response::OfferSnapshot(x) => Ok(Self::OfferSnapshot(x)),
184            Response::LoadSnapshotChunk(x) => Ok(Self::LoadSnapshotChunk(x)),
185            Response::ApplySnapshotChunk(x) => Ok(Self::ApplySnapshotChunk(x)),
186            _ => Err(Error::invalid_abci_response_type()),
187        }
188    }
189}
190
191// =============================================================================
192// Protobuf conversions
193// =============================================================================
194
195use tendermint_proto::v0_37::abci as pb;
196use tendermint_proto::Protobuf;
197
198impl From<Response> for pb::Response {
199    fn from(response: Response) -> pb::Response {
200        use pb::response::Value;
201        let value = match response {
202            Response::Exception(x) => Some(Value::Exception(x.into())),
203            Response::Echo(x) => Some(Value::Echo(x.into())),
204            Response::Flush => Some(Value::Flush(Default::default())),
205            Response::Info(x) => Some(Value::Info(x.into())),
206            Response::InitChain(x) => Some(Value::InitChain(x.into())),
207            Response::Query(x) => Some(Value::Query(x.into())),
208            Response::BeginBlock(x) => Some(Value::BeginBlock(x.into())),
209            Response::CheckTx(x) => Some(Value::CheckTx(x.into())),
210            Response::DeliverTx(x) => Some(Value::DeliverTx(x.into())),
211            Response::EndBlock(x) => Some(Value::EndBlock(x.into())),
212            Response::Commit(x) => Some(Value::Commit(x.into())),
213            Response::ListSnapshots(x) => Some(Value::ListSnapshots(x.into())),
214            Response::OfferSnapshot(x) => Some(Value::OfferSnapshot(x.into())),
215            Response::LoadSnapshotChunk(x) => Some(Value::LoadSnapshotChunk(x.into())),
216            Response::ApplySnapshotChunk(x) => Some(Value::ApplySnapshotChunk(x.into())),
217            Response::PrepareProposal(x) => Some(Value::PrepareProposal(x.into())),
218            Response::ProcessProposal(x) => Some(Value::ProcessProposal(x.into())),
219        };
220        pb::Response { value }
221    }
222}
223
224impl TryFrom<pb::Response> for Response {
225    type Error = Error;
226
227    fn try_from(response: pb::Response) -> Result<Self, Self::Error> {
228        use pb::response::Value;
229        match response.value {
230            Some(Value::Exception(x)) => Ok(Response::Exception(x.try_into()?)),
231            Some(Value::Echo(x)) => Ok(Response::Echo(x.try_into()?)),
232            Some(Value::Flush(_)) => Ok(Response::Flush),
233            Some(Value::Info(x)) => Ok(Response::Info(x.try_into()?)),
234            Some(Value::InitChain(x)) => Ok(Response::InitChain(x.try_into()?)),
235            Some(Value::Query(x)) => Ok(Response::Query(x.try_into()?)),
236            Some(Value::BeginBlock(x)) => Ok(Response::BeginBlock(x.try_into()?)),
237            Some(Value::CheckTx(x)) => Ok(Response::CheckTx(x.try_into()?)),
238            Some(Value::DeliverTx(x)) => Ok(Response::DeliverTx(x.try_into()?)),
239            Some(Value::EndBlock(x)) => Ok(Response::EndBlock(x.try_into()?)),
240            Some(Value::Commit(x)) => Ok(Response::Commit(x.try_into()?)),
241            Some(Value::ListSnapshots(x)) => Ok(Response::ListSnapshots(x.try_into()?)),
242            Some(Value::OfferSnapshot(x)) => Ok(Response::OfferSnapshot(x.try_into()?)),
243            Some(Value::LoadSnapshotChunk(x)) => Ok(Response::LoadSnapshotChunk(x.try_into()?)),
244            Some(Value::ApplySnapshotChunk(x)) => Ok(Response::ApplySnapshotChunk(x.try_into()?)),
245            Some(Value::PrepareProposal(x)) => Ok(Response::PrepareProposal(x.try_into()?)),
246            Some(Value::ProcessProposal(x)) => Ok(Response::ProcessProposal(x.try_into()?)),
247            None => Err(Error::missing_data()),
248        }
249    }
250}
251
252impl Protobuf<pb::Response> for Response {}