celestia_grpc/grpc/
cosmos_tx.rs

1use celestia_proto::cosmos::base::abci::v1beta1::GasInfo;
2use celestia_proto::cosmos::tx::v1beta1::{
3    BroadcastTxRequest, BroadcastTxResponse, GetTxRequest as RawGetTxRequest,
4    GetTxResponse as RawGetTxResponse, SimulateRequest, SimulateResponse,
5};
6use celestia_types::hash::Hash;
7use celestia_types::state::{Tx, TxResponse};
8#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
9use wasm_bindgen::prelude::*;
10
11use crate::grpc::{FromGrpcResponse, IntoGrpcParam};
12use crate::{Error, Result};
13
14pub use celestia_proto::cosmos::tx::v1beta1::BroadcastMode;
15
16/// Response to GetTx
17#[derive(Debug)]
18#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
19#[cfg_attr(
20    all(target_arch = "wasm32", feature = "wasm-bindgen"),
21    wasm_bindgen(getter_with_clone)
22)]
23pub struct GetTxResponse {
24    /// Response Transaction
25    pub tx: Tx,
26
27    /// TxResponse to a Query
28    pub tx_response: TxResponse,
29}
30
31impl IntoGrpcParam<BroadcastTxRequest> for (Vec<u8>, BroadcastMode) {
32    fn into_parameter(self) -> BroadcastTxRequest {
33        let (tx_bytes, mode) = self;
34
35        BroadcastTxRequest {
36            tx_bytes,
37            mode: mode.into(),
38        }
39    }
40}
41
42impl FromGrpcResponse<TxResponse> for BroadcastTxResponse {
43    fn try_from_response(self) -> Result<TxResponse> {
44        Ok(self
45            .tx_response
46            .ok_or(Error::FailedToParseResponse)?
47            .try_into()?)
48    }
49}
50
51impl IntoGrpcParam<RawGetTxRequest> for Hash {
52    fn into_parameter(self) -> RawGetTxRequest {
53        RawGetTxRequest {
54            hash: self.to_string(),
55        }
56    }
57}
58
59impl FromGrpcResponse<GetTxResponse> for RawGetTxResponse {
60    fn try_from_response(self) -> Result<GetTxResponse> {
61        let tx_response = self
62            .tx_response
63            .ok_or(Error::FailedToParseResponse)?
64            .try_into()?;
65
66        let tx = self.tx.ok_or(Error::FailedToParseResponse)?;
67
68        let cosmos_tx = Tx {
69            body: tx.body.ok_or(Error::FailedToParseResponse)?.try_into()?,
70            auth_info: tx
71                .auth_info
72                .ok_or(Error::FailedToParseResponse)?
73                .try_into()?,
74            signatures: tx.signatures,
75        };
76
77        Ok(GetTxResponse {
78            tx: cosmos_tx,
79            tx_response,
80        })
81    }
82}
83
84impl IntoGrpcParam<SimulateRequest> for Vec<u8> {
85    fn into_parameter(self) -> SimulateRequest {
86        SimulateRequest {
87            tx_bytes: self,
88            ..SimulateRequest::default()
89        }
90    }
91}
92
93impl FromGrpcResponse<GasInfo> for SimulateResponse {
94    fn try_from_response(self) -> Result<GasInfo> {
95        self.gas_info.ok_or(Error::FailedToParseResponse)
96    }
97}
98
99#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
100pub use wbg::*;
101
102#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
103mod wbg {
104    use super::BroadcastMode;
105    use wasm_bindgen::prelude::*;
106
107    /// BroadcastMode specifies the broadcast mode for the TxService.Broadcast RPC method.
108    #[derive(Debug, Clone, Copy)]
109    #[wasm_bindgen(js_name = BroadcastMode)]
110    pub struct JsBroadcastMode(BroadcastMode);
111
112    #[wasm_bindgen(js_class = BroadcastMode)]
113    impl JsBroadcastMode {
114        /// zero-value for mode ordering
115        #[wasm_bindgen(js_name = Unspecified, getter)]
116        pub fn unspecified() -> JsBroadcastMode {
117            BroadcastMode::Unspecified.into()
118        }
119
120        /// DEPRECATED: use `BroadcastMode` `Sync` instead,
121        /// `BroadcastMode` `Block` is not supported by the SDK from v0.47.x onwards.
122        #[wasm_bindgen(js_name = Block, getter)]
123        pub fn block() -> JsBroadcastMode {
124            BroadcastMode::Block.into()
125        }
126
127        /// `BroadcastMode` `Sync` defines a tx broadcasting mode where the client waits for
128        /// a CheckTx execution response only.
129        #[wasm_bindgen(js_name = Sync, getter)]
130        pub fn sync() -> JsBroadcastMode {
131            BroadcastMode::Sync.into()
132        }
133
134        /// `BroadcastMode` `Async` defines a tx broadcasting mode where the client returns
135        /// immediately.
136        #[wasm_bindgen(js_name = Async, getter)]
137        pub fn _async() -> JsBroadcastMode {
138            BroadcastMode::Async.into()
139        }
140    }
141
142    impl From<BroadcastMode> for JsBroadcastMode {
143        fn from(value: BroadcastMode) -> Self {
144            JsBroadcastMode(value)
145        }
146    }
147
148    impl From<JsBroadcastMode> for BroadcastMode {
149        fn from(value: JsBroadcastMode) -> Self {
150            value.0
151        }
152    }
153}