tendermint_rpc/endpoint/
block_search.rs

1//! `/block_search` endpoint JSON-RPC wrapper
2
3use serde::{Deserialize, Serialize};
4
5use crate::dialect;
6use crate::dialect::Dialect;
7use crate::prelude::*;
8use crate::request::RequestMessage;
9use crate::serializers;
10use crate::{Method, Order};
11
12pub use super::{block, block_results};
13
14/// Request for searching for blocks by their BeginBlock and EndBlock events.
15#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
16pub struct Request {
17    pub query: String,
18    #[serde(with = "serializers::from_str")]
19    pub page: u32,
20    #[serde(with = "serializers::from_str")]
21    pub per_page: u8,
22    pub order_by: Order,
23}
24
25impl Request {
26    /// Constructor.
27    pub fn new(query: impl ToString, page: u32, per_page: u8, order_by: Order) -> Self {
28        Self {
29            query: query.to_string(),
30            page,
31            per_page,
32            order_by,
33        }
34    }
35}
36
37impl RequestMessage for Request {
38    fn method(&self) -> Method {
39        Method::BlockSearch
40    }
41}
42
43impl crate::Request<dialect::v0_34::Dialect> for Request {
44    type Response = Response;
45}
46
47impl crate::Request<dialect::v0_37::Dialect> for Request {
48    type Response = Response;
49}
50
51impl crate::Request<dialect::v0_38::Dialect> for Request {
52    type Response = self::v0_38::DialectResponse;
53}
54
55impl<S: Dialect> crate::SimpleRequest<S> for Request
56where
57    Self: crate::Request<S>,
58    Response: From<Self::Response>,
59{
60    type Output = Response;
61}
62
63#[derive(Clone, Debug, Deserialize, Serialize)]
64pub struct Response {
65    pub blocks: Vec<block::Response>,
66    #[serde(with = "serializers::from_str")]
67    pub total_count: u32,
68}
69
70impl crate::Response for Response {}
71
72pub mod v0_38 {
73    use super::*;
74
75    #[derive(Clone, Debug, Deserialize, Serialize)]
76    pub struct DialectResponse {
77        pub blocks: Vec<block::v0_38::DialectResponse>,
78
79        #[serde(with = "serializers::from_str")]
80        pub total_count: u32,
81    }
82
83    impl crate::Response for DialectResponse {}
84
85    impl From<DialectResponse> for Response {
86        fn from(response: DialectResponse) -> Self {
87            Response {
88                blocks: response.blocks.into_iter().map(Into::into).collect(),
89                total_count: response.total_count,
90            }
91        }
92    }
93}