ddk_node/
ddkrpc.rs

1// This file is @generated by prost-build.
2#[derive(serde::Serialize, serde::Deserialize)]
3#[allow(clippy::derive_partial_eq_without_eq)]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct InfoRequest {}
6#[derive(serde::Serialize, serde::Deserialize)]
7#[allow(clippy::derive_partial_eq_without_eq)]
8#[derive(Clone, PartialEq, ::prost::Message)]
9pub struct InfoResponse {
10    #[prost(string, tag = "1")]
11    pub pubkey: ::prost::alloc::string::String,
12    #[prost(string, tag = "2")]
13    pub transport: ::prost::alloc::string::String,
14    #[prost(string, tag = "3")]
15    pub oracle: ::prost::alloc::string::String,
16}
17#[derive(serde::Serialize, serde::Deserialize)]
18#[allow(clippy::derive_partial_eq_without_eq)]
19#[derive(Clone, PartialEq, ::prost::Message)]
20pub struct SendOfferRequest {
21    #[prost(bytes = "vec", tag = "1")]
22    pub contract_input: ::prost::alloc::vec::Vec<u8>,
23    #[prost(string, tag = "2")]
24    pub counter_party: ::prost::alloc::string::String,
25}
26#[derive(serde::Serialize, serde::Deserialize)]
27#[allow(clippy::derive_partial_eq_without_eq)]
28#[derive(Clone, PartialEq, ::prost::Message)]
29pub struct SendOfferResponse {
30    #[prost(bytes = "vec", tag = "1")]
31    pub offer_dlc: ::prost::alloc::vec::Vec<u8>,
32}
33#[derive(serde::Serialize, serde::Deserialize)]
34#[allow(clippy::derive_partial_eq_without_eq)]
35#[derive(Clone, PartialEq, ::prost::Message)]
36pub struct ListOffersRequest {}
37#[derive(serde::Serialize, serde::Deserialize)]
38#[allow(clippy::derive_partial_eq_without_eq)]
39#[derive(Clone, PartialEq, ::prost::Message)]
40pub struct ListOffersResponse {
41    #[prost(bytes = "vec", repeated, tag = "1")]
42    pub offers: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
43}
44#[derive(serde::Serialize, serde::Deserialize)]
45#[allow(clippy::derive_partial_eq_without_eq)]
46#[derive(Clone, PartialEq, ::prost::Message)]
47pub struct AcceptOfferRequest {
48    #[prost(string, tag = "1")]
49    pub contract_id: ::prost::alloc::string::String,
50}
51#[derive(serde::Serialize, serde::Deserialize)]
52#[allow(clippy::derive_partial_eq_without_eq)]
53#[derive(Clone, PartialEq, ::prost::Message)]
54pub struct AcceptOfferResponse {
55    #[prost(string, tag = "1")]
56    pub contract_id: ::prost::alloc::string::String,
57    #[prost(string, tag = "2")]
58    pub counter_party: ::prost::alloc::string::String,
59    #[prost(bytes = "vec", tag = "3")]
60    pub accept_dlc: ::prost::alloc::vec::Vec<u8>,
61}
62#[derive(serde::Serialize, serde::Deserialize)]
63#[allow(clippy::derive_partial_eq_without_eq)]
64#[derive(Clone, PartialEq, ::prost::Message)]
65pub struct NewAddressRequest {}
66#[derive(serde::Serialize, serde::Deserialize)]
67#[allow(clippy::derive_partial_eq_without_eq)]
68#[derive(Clone, PartialEq, ::prost::Message)]
69pub struct NewAddressResponse {
70    #[prost(string, tag = "1")]
71    pub address: ::prost::alloc::string::String,
72}
73#[derive(serde::Serialize, serde::Deserialize)]
74#[allow(clippy::derive_partial_eq_without_eq)]
75#[derive(Clone, PartialEq, ::prost::Message)]
76pub struct WalletBalanceRequest {}
77#[derive(serde::Serialize, serde::Deserialize)]
78#[allow(clippy::derive_partial_eq_without_eq)]
79#[derive(Clone, PartialEq, ::prost::Message)]
80pub struct WalletBalanceResponse {
81    #[prost(uint64, tag = "1")]
82    pub confirmed: u64,
83    #[prost(uint64, tag = "2")]
84    pub foreign_unconfirmed: u64,
85    #[prost(uint64, tag = "3")]
86    pub change_unconfirmed: u64,
87    #[prost(int64, tag = "4")]
88    pub contract_balance: i64,
89}
90#[derive(serde::Serialize, serde::Deserialize)]
91#[allow(clippy::derive_partial_eq_without_eq)]
92#[derive(Clone, PartialEq, ::prost::Message)]
93pub struct GetWalletTransactionsRequest {}
94#[derive(serde::Serialize, serde::Deserialize)]
95#[allow(clippy::derive_partial_eq_without_eq)]
96#[derive(Clone, PartialEq, ::prost::Message)]
97pub struct GetWalletTransactionsResponse {
98    #[prost(bytes = "vec", repeated, tag = "1")]
99    pub transactions: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
100}
101#[derive(serde::Serialize, serde::Deserialize)]
102#[allow(clippy::derive_partial_eq_without_eq)]
103#[derive(Clone, PartialEq, ::prost::Message)]
104pub struct ListUtxosRequest {}
105#[derive(serde::Serialize, serde::Deserialize)]
106#[allow(clippy::derive_partial_eq_without_eq)]
107#[derive(Clone, PartialEq, ::prost::Message)]
108pub struct ListUtxosResponse {
109    #[prost(bytes = "vec", repeated, tag = "1")]
110    pub utxos: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
111}
112#[derive(serde::Serialize, serde::Deserialize)]
113#[allow(clippy::derive_partial_eq_without_eq)]
114#[derive(Clone, PartialEq, ::prost::Message)]
115pub struct ListPeersRequest {}
116#[derive(serde::Serialize, serde::Deserialize)]
117#[allow(clippy::derive_partial_eq_without_eq)]
118#[derive(Clone, PartialEq, ::prost::Message)]
119pub struct ListPeersResponse {
120    #[prost(message, repeated, tag = "1")]
121    pub peers: ::prost::alloc::vec::Vec<Peer>,
122}
123#[derive(serde::Serialize, serde::Deserialize)]
124#[allow(clippy::derive_partial_eq_without_eq)]
125#[derive(Clone, PartialEq, ::prost::Message)]
126pub struct Peer {
127    #[prost(string, tag = "1")]
128    pub pubkey: ::prost::alloc::string::String,
129    #[prost(string, tag = "2")]
130    pub host: ::prost::alloc::string::String,
131}
132#[derive(serde::Serialize, serde::Deserialize)]
133#[allow(clippy::derive_partial_eq_without_eq)]
134#[derive(Clone, PartialEq, ::prost::Message)]
135pub struct ConnectRequest {
136    #[prost(string, tag = "1")]
137    pub pubkey: ::prost::alloc::string::String,
138    #[prost(string, tag = "2")]
139    pub host: ::prost::alloc::string::String,
140}
141#[derive(serde::Serialize, serde::Deserialize)]
142#[allow(clippy::derive_partial_eq_without_eq)]
143#[derive(Clone, PartialEq, ::prost::Message)]
144pub struct ConnectResponse {}
145#[derive(serde::Serialize, serde::Deserialize)]
146#[allow(clippy::derive_partial_eq_without_eq)]
147#[derive(Clone, PartialEq, ::prost::Message)]
148pub struct ListOraclesRequest {}
149#[derive(serde::Serialize, serde::Deserialize)]
150#[allow(clippy::derive_partial_eq_without_eq)]
151#[derive(Clone, PartialEq, ::prost::Message)]
152pub struct ListOraclesResponse {
153    #[prost(string, tag = "1")]
154    pub name: ::prost::alloc::string::String,
155    #[prost(string, tag = "2")]
156    pub pubkey: ::prost::alloc::string::String,
157}
158#[derive(serde::Serialize, serde::Deserialize)]
159#[allow(clippy::derive_partial_eq_without_eq)]
160#[derive(Clone, PartialEq, ::prost::Message)]
161pub struct ListContractsRequest {}
162#[derive(serde::Serialize, serde::Deserialize)]
163#[allow(clippy::derive_partial_eq_without_eq)]
164#[derive(Clone, PartialEq, ::prost::Message)]
165pub struct ListContractsResponse {
166    #[prost(bytes = "vec", repeated, tag = "1")]
167    pub contracts: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
168}
169#[derive(serde::Serialize, serde::Deserialize)]
170#[allow(clippy::derive_partial_eq_without_eq)]
171#[derive(Clone, PartialEq, ::prost::Message)]
172pub struct SendRequest {
173    #[prost(string, tag = "1")]
174    pub address: ::prost::alloc::string::String,
175    #[prost(uint64, tag = "2")]
176    pub amount: u64,
177    #[prost(uint64, tag = "3")]
178    pub fee_rate: u64,
179}
180#[derive(serde::Serialize, serde::Deserialize)]
181#[allow(clippy::derive_partial_eq_without_eq)]
182#[derive(Clone, PartialEq, ::prost::Message)]
183pub struct SendResponse {
184    #[prost(string, tag = "1")]
185    pub txid: ::prost::alloc::string::String,
186}
187#[derive(serde::Serialize, serde::Deserialize)]
188#[allow(clippy::derive_partial_eq_without_eq)]
189#[derive(Clone, PartialEq, ::prost::Message)]
190pub struct OracleAnnouncementsRequest {}
191#[derive(serde::Serialize, serde::Deserialize)]
192#[allow(clippy::derive_partial_eq_without_eq)]
193#[derive(Clone, PartialEq, ::prost::Message)]
194pub struct OracleAnnouncementsResponse {
195    #[prost(bytes = "vec", repeated, tag = "1")]
196    pub announcements: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
197}
198#[derive(serde::Serialize, serde::Deserialize)]
199#[allow(clippy::derive_partial_eq_without_eq)]
200#[derive(Clone, PartialEq, ::prost::Message)]
201pub struct WalletSyncRequest {}
202#[derive(serde::Serialize, serde::Deserialize)]
203#[allow(clippy::derive_partial_eq_without_eq)]
204#[derive(Clone, PartialEq, ::prost::Message)]
205pub struct WalletSyncResponse {}
206/// Generated client implementations.
207pub mod ddk_rpc_client {
208    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
209    use tonic::codegen::*;
210    use tonic::codegen::http::Uri;
211    #[derive(Debug, Clone)]
212    pub struct DdkRpcClient<T> {
213        inner: tonic::client::Grpc<T>,
214    }
215    impl DdkRpcClient<tonic::transport::Channel> {
216        /// Attempt to create a new client by connecting to a given endpoint.
217        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
218        where
219            D: TryInto<tonic::transport::Endpoint>,
220            D::Error: Into<StdError>,
221        {
222            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
223            Ok(Self::new(conn))
224        }
225    }
226    impl<T> DdkRpcClient<T>
227    where
228        T: tonic::client::GrpcService<tonic::body::BoxBody>,
229        T::Error: Into<StdError>,
230        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
231        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
232    {
233        pub fn new(inner: T) -> Self {
234            let inner = tonic::client::Grpc::new(inner);
235            Self { inner }
236        }
237        pub fn with_origin(inner: T, origin: Uri) -> Self {
238            let inner = tonic::client::Grpc::with_origin(inner, origin);
239            Self { inner }
240        }
241        pub fn with_interceptor<F>(
242            inner: T,
243            interceptor: F,
244        ) -> DdkRpcClient<InterceptedService<T, F>>
245        where
246            F: tonic::service::Interceptor,
247            T::ResponseBody: Default,
248            T: tonic::codegen::Service<
249                http::Request<tonic::body::BoxBody>,
250                Response = http::Response<
251                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
252                >,
253            >,
254            <T as tonic::codegen::Service<
255                http::Request<tonic::body::BoxBody>,
256            >>::Error: Into<StdError> + Send + Sync,
257        {
258            DdkRpcClient::new(InterceptedService::new(inner, interceptor))
259        }
260        /// Compress requests with the given encoding.
261        ///
262        /// This requires the server to support it otherwise it might respond with an
263        /// error.
264        #[must_use]
265        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
266            self.inner = self.inner.send_compressed(encoding);
267            self
268        }
269        /// Enable decompressing responses.
270        #[must_use]
271        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
272            self.inner = self.inner.accept_compressed(encoding);
273            self
274        }
275        /// Limits the maximum size of a decoded message.
276        ///
277        /// Default: `4MB`
278        #[must_use]
279        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
280            self.inner = self.inner.max_decoding_message_size(limit);
281            self
282        }
283        /// Limits the maximum size of an encoded message.
284        ///
285        /// Default: `usize::MAX`
286        #[must_use]
287        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
288            self.inner = self.inner.max_encoding_message_size(limit);
289            self
290        }
291        pub async fn info(
292            &mut self,
293            request: impl tonic::IntoRequest<super::InfoRequest>,
294        ) -> std::result::Result<tonic::Response<super::InfoResponse>, tonic::Status> {
295            self.inner
296                .ready()
297                .await
298                .map_err(|e| {
299                    tonic::Status::new(
300                        tonic::Code::Unknown,
301                        format!("Service was not ready: {}", e.into()),
302                    )
303                })?;
304            let codec = tonic::codec::ProstCodec::default();
305            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Info");
306            let mut req = request.into_request();
307            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Info"));
308            self.inner.unary(req, path, codec).await
309        }
310        pub async fn send_offer(
311            &mut self,
312            request: impl tonic::IntoRequest<super::SendOfferRequest>,
313        ) -> std::result::Result<
314            tonic::Response<super::SendOfferResponse>,
315            tonic::Status,
316        > {
317            self.inner
318                .ready()
319                .await
320                .map_err(|e| {
321                    tonic::Status::new(
322                        tonic::Code::Unknown,
323                        format!("Service was not ready: {}", e.into()),
324                    )
325                })?;
326            let codec = tonic::codec::ProstCodec::default();
327            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/SendOffer");
328            let mut req = request.into_request();
329            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "SendOffer"));
330            self.inner.unary(req, path, codec).await
331        }
332        pub async fn accept_offer(
333            &mut self,
334            request: impl tonic::IntoRequest<super::AcceptOfferRequest>,
335        ) -> std::result::Result<
336            tonic::Response<super::AcceptOfferResponse>,
337            tonic::Status,
338        > {
339            self.inner
340                .ready()
341                .await
342                .map_err(|e| {
343                    tonic::Status::new(
344                        tonic::Code::Unknown,
345                        format!("Service was not ready: {}", e.into()),
346                    )
347                })?;
348            let codec = tonic::codec::ProstCodec::default();
349            let path = http::uri::PathAndQuery::from_static(
350                "/ddkrpc.DdkRpc/AcceptOffer",
351            );
352            let mut req = request.into_request();
353            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "AcceptOffer"));
354            self.inner.unary(req, path, codec).await
355        }
356        pub async fn list_offers(
357            &mut self,
358            request: impl tonic::IntoRequest<super::ListOffersRequest>,
359        ) -> std::result::Result<
360            tonic::Response<super::ListOffersResponse>,
361            tonic::Status,
362        > {
363            self.inner
364                .ready()
365                .await
366                .map_err(|e| {
367                    tonic::Status::new(
368                        tonic::Code::Unknown,
369                        format!("Service was not ready: {}", e.into()),
370                    )
371                })?;
372            let codec = tonic::codec::ProstCodec::default();
373            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListOffers");
374            let mut req = request.into_request();
375            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOffers"));
376            self.inner.unary(req, path, codec).await
377        }
378        pub async fn new_address(
379            &mut self,
380            request: impl tonic::IntoRequest<super::NewAddressRequest>,
381        ) -> std::result::Result<
382            tonic::Response<super::NewAddressResponse>,
383            tonic::Status,
384        > {
385            self.inner
386                .ready()
387                .await
388                .map_err(|e| {
389                    tonic::Status::new(
390                        tonic::Code::Unknown,
391                        format!("Service was not ready: {}", e.into()),
392                    )
393                })?;
394            let codec = tonic::codec::ProstCodec::default();
395            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/NewAddress");
396            let mut req = request.into_request();
397            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "NewAddress"));
398            self.inner.unary(req, path, codec).await
399        }
400        pub async fn wallet_balance(
401            &mut self,
402            request: impl tonic::IntoRequest<super::WalletBalanceRequest>,
403        ) -> std::result::Result<
404            tonic::Response<super::WalletBalanceResponse>,
405            tonic::Status,
406        > {
407            self.inner
408                .ready()
409                .await
410                .map_err(|e| {
411                    tonic::Status::new(
412                        tonic::Code::Unknown,
413                        format!("Service was not ready: {}", e.into()),
414                    )
415                })?;
416            let codec = tonic::codec::ProstCodec::default();
417            let path = http::uri::PathAndQuery::from_static(
418                "/ddkrpc.DdkRpc/WalletBalance",
419            );
420            let mut req = request.into_request();
421            req.extensions_mut()
422                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "WalletBalance"));
423            self.inner.unary(req, path, codec).await
424        }
425        pub async fn wallet_sync(
426            &mut self,
427            request: impl tonic::IntoRequest<super::WalletSyncRequest>,
428        ) -> std::result::Result<
429            tonic::Response<super::WalletSyncResponse>,
430            tonic::Status,
431        > {
432            self.inner
433                .ready()
434                .await
435                .map_err(|e| {
436                    tonic::Status::new(
437                        tonic::Code::Unknown,
438                        format!("Service was not ready: {}", e.into()),
439                    )
440                })?;
441            let codec = tonic::codec::ProstCodec::default();
442            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/WalletSync");
443            let mut req = request.into_request();
444            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "WalletSync"));
445            self.inner.unary(req, path, codec).await
446        }
447        pub async fn get_wallet_transactions(
448            &mut self,
449            request: impl tonic::IntoRequest<super::GetWalletTransactionsRequest>,
450        ) -> std::result::Result<
451            tonic::Response<super::GetWalletTransactionsResponse>,
452            tonic::Status,
453        > {
454            self.inner
455                .ready()
456                .await
457                .map_err(|e| {
458                    tonic::Status::new(
459                        tonic::Code::Unknown,
460                        format!("Service was not ready: {}", e.into()),
461                    )
462                })?;
463            let codec = tonic::codec::ProstCodec::default();
464            let path = http::uri::PathAndQuery::from_static(
465                "/ddkrpc.DdkRpc/GetWalletTransactions",
466            );
467            let mut req = request.into_request();
468            req.extensions_mut()
469                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "GetWalletTransactions"));
470            self.inner.unary(req, path, codec).await
471        }
472        pub async fn list_utxos(
473            &mut self,
474            request: impl tonic::IntoRequest<super::ListUtxosRequest>,
475        ) -> std::result::Result<
476            tonic::Response<super::ListUtxosResponse>,
477            tonic::Status,
478        > {
479            self.inner
480                .ready()
481                .await
482                .map_err(|e| {
483                    tonic::Status::new(
484                        tonic::Code::Unknown,
485                        format!("Service was not ready: {}", e.into()),
486                    )
487                })?;
488            let codec = tonic::codec::ProstCodec::default();
489            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListUtxos");
490            let mut req = request.into_request();
491            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListUtxos"));
492            self.inner.unary(req, path, codec).await
493        }
494        pub async fn list_peers(
495            &mut self,
496            request: impl tonic::IntoRequest<super::ListPeersRequest>,
497        ) -> std::result::Result<
498            tonic::Response<super::ListPeersResponse>,
499            tonic::Status,
500        > {
501            self.inner
502                .ready()
503                .await
504                .map_err(|e| {
505                    tonic::Status::new(
506                        tonic::Code::Unknown,
507                        format!("Service was not ready: {}", e.into()),
508                    )
509                })?;
510            let codec = tonic::codec::ProstCodec::default();
511            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListPeers");
512            let mut req = request.into_request();
513            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListPeers"));
514            self.inner.unary(req, path, codec).await
515        }
516        pub async fn connect_peer(
517            &mut self,
518            request: impl tonic::IntoRequest<super::ConnectRequest>,
519        ) -> std::result::Result<
520            tonic::Response<super::ConnectResponse>,
521            tonic::Status,
522        > {
523            self.inner
524                .ready()
525                .await
526                .map_err(|e| {
527                    tonic::Status::new(
528                        tonic::Code::Unknown,
529                        format!("Service was not ready: {}", e.into()),
530                    )
531                })?;
532            let codec = tonic::codec::ProstCodec::default();
533            let path = http::uri::PathAndQuery::from_static(
534                "/ddkrpc.DdkRpc/ConnectPeer",
535            );
536            let mut req = request.into_request();
537            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ConnectPeer"));
538            self.inner.unary(req, path, codec).await
539        }
540        pub async fn list_oracles(
541            &mut self,
542            request: impl tonic::IntoRequest<super::ListOraclesRequest>,
543        ) -> std::result::Result<
544            tonic::Response<super::ListOraclesResponse>,
545            tonic::Status,
546        > {
547            self.inner
548                .ready()
549                .await
550                .map_err(|e| {
551                    tonic::Status::new(
552                        tonic::Code::Unknown,
553                        format!("Service was not ready: {}", e.into()),
554                    )
555                })?;
556            let codec = tonic::codec::ProstCodec::default();
557            let path = http::uri::PathAndQuery::from_static(
558                "/ddkrpc.DdkRpc/ListOracles",
559            );
560            let mut req = request.into_request();
561            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOracles"));
562            self.inner.unary(req, path, codec).await
563        }
564        pub async fn list_contracts(
565            &mut self,
566            request: impl tonic::IntoRequest<super::ListContractsRequest>,
567        ) -> std::result::Result<
568            tonic::Response<super::ListContractsResponse>,
569            tonic::Status,
570        > {
571            self.inner
572                .ready()
573                .await
574                .map_err(|e| {
575                    tonic::Status::new(
576                        tonic::Code::Unknown,
577                        format!("Service was not ready: {}", e.into()),
578                    )
579                })?;
580            let codec = tonic::codec::ProstCodec::default();
581            let path = http::uri::PathAndQuery::from_static(
582                "/ddkrpc.DdkRpc/ListContracts",
583            );
584            let mut req = request.into_request();
585            req.extensions_mut()
586                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListContracts"));
587            self.inner.unary(req, path, codec).await
588        }
589        pub async fn send(
590            &mut self,
591            request: impl tonic::IntoRequest<super::SendRequest>,
592        ) -> std::result::Result<tonic::Response<super::SendResponse>, tonic::Status> {
593            self.inner
594                .ready()
595                .await
596                .map_err(|e| {
597                    tonic::Status::new(
598                        tonic::Code::Unknown,
599                        format!("Service was not ready: {}", e.into()),
600                    )
601                })?;
602            let codec = tonic::codec::ProstCodec::default();
603            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Send");
604            let mut req = request.into_request();
605            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Send"));
606            self.inner.unary(req, path, codec).await
607        }
608        pub async fn oracle_announcements(
609            &mut self,
610            request: impl tonic::IntoRequest<super::OracleAnnouncementsRequest>,
611        ) -> std::result::Result<
612            tonic::Response<super::OracleAnnouncementsResponse>,
613            tonic::Status,
614        > {
615            self.inner
616                .ready()
617                .await
618                .map_err(|e| {
619                    tonic::Status::new(
620                        tonic::Code::Unknown,
621                        format!("Service was not ready: {}", e.into()),
622                    )
623                })?;
624            let codec = tonic::codec::ProstCodec::default();
625            let path = http::uri::PathAndQuery::from_static(
626                "/ddkrpc.DdkRpc/OracleAnnouncements",
627            );
628            let mut req = request.into_request();
629            req.extensions_mut()
630                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "OracleAnnouncements"));
631            self.inner.unary(req, path, codec).await
632        }
633    }
634}
635/// Generated server implementations.
636pub mod ddk_rpc_server {
637    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
638    use tonic::codegen::*;
639    /// Generated trait containing gRPC methods that should be implemented for use with DdkRpcServer.
640    #[async_trait]
641    pub trait DdkRpc: Send + Sync + 'static {
642        async fn info(
643            &self,
644            request: tonic::Request<super::InfoRequest>,
645        ) -> std::result::Result<tonic::Response<super::InfoResponse>, tonic::Status>;
646        async fn send_offer(
647            &self,
648            request: tonic::Request<super::SendOfferRequest>,
649        ) -> std::result::Result<
650            tonic::Response<super::SendOfferResponse>,
651            tonic::Status,
652        >;
653        async fn accept_offer(
654            &self,
655            request: tonic::Request<super::AcceptOfferRequest>,
656        ) -> std::result::Result<
657            tonic::Response<super::AcceptOfferResponse>,
658            tonic::Status,
659        >;
660        async fn list_offers(
661            &self,
662            request: tonic::Request<super::ListOffersRequest>,
663        ) -> std::result::Result<
664            tonic::Response<super::ListOffersResponse>,
665            tonic::Status,
666        >;
667        async fn new_address(
668            &self,
669            request: tonic::Request<super::NewAddressRequest>,
670        ) -> std::result::Result<
671            tonic::Response<super::NewAddressResponse>,
672            tonic::Status,
673        >;
674        async fn wallet_balance(
675            &self,
676            request: tonic::Request<super::WalletBalanceRequest>,
677        ) -> std::result::Result<
678            tonic::Response<super::WalletBalanceResponse>,
679            tonic::Status,
680        >;
681        async fn wallet_sync(
682            &self,
683            request: tonic::Request<super::WalletSyncRequest>,
684        ) -> std::result::Result<
685            tonic::Response<super::WalletSyncResponse>,
686            tonic::Status,
687        >;
688        async fn get_wallet_transactions(
689            &self,
690            request: tonic::Request<super::GetWalletTransactionsRequest>,
691        ) -> std::result::Result<
692            tonic::Response<super::GetWalletTransactionsResponse>,
693            tonic::Status,
694        >;
695        async fn list_utxos(
696            &self,
697            request: tonic::Request<super::ListUtxosRequest>,
698        ) -> std::result::Result<
699            tonic::Response<super::ListUtxosResponse>,
700            tonic::Status,
701        >;
702        async fn list_peers(
703            &self,
704            request: tonic::Request<super::ListPeersRequest>,
705        ) -> std::result::Result<
706            tonic::Response<super::ListPeersResponse>,
707            tonic::Status,
708        >;
709        async fn connect_peer(
710            &self,
711            request: tonic::Request<super::ConnectRequest>,
712        ) -> std::result::Result<tonic::Response<super::ConnectResponse>, tonic::Status>;
713        async fn list_oracles(
714            &self,
715            request: tonic::Request<super::ListOraclesRequest>,
716        ) -> std::result::Result<
717            tonic::Response<super::ListOraclesResponse>,
718            tonic::Status,
719        >;
720        async fn list_contracts(
721            &self,
722            request: tonic::Request<super::ListContractsRequest>,
723        ) -> std::result::Result<
724            tonic::Response<super::ListContractsResponse>,
725            tonic::Status,
726        >;
727        async fn send(
728            &self,
729            request: tonic::Request<super::SendRequest>,
730        ) -> std::result::Result<tonic::Response<super::SendResponse>, tonic::Status>;
731        async fn oracle_announcements(
732            &self,
733            request: tonic::Request<super::OracleAnnouncementsRequest>,
734        ) -> std::result::Result<
735            tonic::Response<super::OracleAnnouncementsResponse>,
736            tonic::Status,
737        >;
738    }
739    #[derive(Debug)]
740    pub struct DdkRpcServer<T: DdkRpc> {
741        inner: _Inner<T>,
742        accept_compression_encodings: EnabledCompressionEncodings,
743        send_compression_encodings: EnabledCompressionEncodings,
744        max_decoding_message_size: Option<usize>,
745        max_encoding_message_size: Option<usize>,
746    }
747    struct _Inner<T>(Arc<T>);
748    impl<T: DdkRpc> DdkRpcServer<T> {
749        pub fn new(inner: T) -> Self {
750            Self::from_arc(Arc::new(inner))
751        }
752        pub fn from_arc(inner: Arc<T>) -> Self {
753            let inner = _Inner(inner);
754            Self {
755                inner,
756                accept_compression_encodings: Default::default(),
757                send_compression_encodings: Default::default(),
758                max_decoding_message_size: None,
759                max_encoding_message_size: None,
760            }
761        }
762        pub fn with_interceptor<F>(
763            inner: T,
764            interceptor: F,
765        ) -> InterceptedService<Self, F>
766        where
767            F: tonic::service::Interceptor,
768        {
769            InterceptedService::new(Self::new(inner), interceptor)
770        }
771        /// Enable decompressing requests with the given encoding.
772        #[must_use]
773        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
774            self.accept_compression_encodings.enable(encoding);
775            self
776        }
777        /// Compress responses with the given encoding, if the client supports it.
778        #[must_use]
779        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
780            self.send_compression_encodings.enable(encoding);
781            self
782        }
783        /// Limits the maximum size of a decoded message.
784        ///
785        /// Default: `4MB`
786        #[must_use]
787        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
788            self.max_decoding_message_size = Some(limit);
789            self
790        }
791        /// Limits the maximum size of an encoded message.
792        ///
793        /// Default: `usize::MAX`
794        #[must_use]
795        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
796            self.max_encoding_message_size = Some(limit);
797            self
798        }
799    }
800    impl<T, B> tonic::codegen::Service<http::Request<B>> for DdkRpcServer<T>
801    where
802        T: DdkRpc,
803        B: Body + Send + 'static,
804        B::Error: Into<StdError> + Send + 'static,
805    {
806        type Response = http::Response<tonic::body::BoxBody>;
807        type Error = std::convert::Infallible;
808        type Future = BoxFuture<Self::Response, Self::Error>;
809        fn poll_ready(
810            &mut self,
811            _cx: &mut Context<'_>,
812        ) -> Poll<std::result::Result<(), Self::Error>> {
813            Poll::Ready(Ok(()))
814        }
815        fn call(&mut self, req: http::Request<B>) -> Self::Future {
816            let inner = self.inner.clone();
817            match req.uri().path() {
818                "/ddkrpc.DdkRpc/Info" => {
819                    #[allow(non_camel_case_types)]
820                    struct InfoSvc<T: DdkRpc>(pub Arc<T>);
821                    impl<T: DdkRpc> tonic::server::UnaryService<super::InfoRequest>
822                    for InfoSvc<T> {
823                        type Response = super::InfoResponse;
824                        type Future = BoxFuture<
825                            tonic::Response<Self::Response>,
826                            tonic::Status,
827                        >;
828                        fn call(
829                            &mut self,
830                            request: tonic::Request<super::InfoRequest>,
831                        ) -> Self::Future {
832                            let inner = Arc::clone(&self.0);
833                            let fut = async move {
834                                <T as DdkRpc>::info(&inner, request).await
835                            };
836                            Box::pin(fut)
837                        }
838                    }
839                    let accept_compression_encodings = self.accept_compression_encodings;
840                    let send_compression_encodings = self.send_compression_encodings;
841                    let max_decoding_message_size = self.max_decoding_message_size;
842                    let max_encoding_message_size = self.max_encoding_message_size;
843                    let inner = self.inner.clone();
844                    let fut = async move {
845                        let inner = inner.0;
846                        let method = InfoSvc(inner);
847                        let codec = tonic::codec::ProstCodec::default();
848                        let mut grpc = tonic::server::Grpc::new(codec)
849                            .apply_compression_config(
850                                accept_compression_encodings,
851                                send_compression_encodings,
852                            )
853                            .apply_max_message_size_config(
854                                max_decoding_message_size,
855                                max_encoding_message_size,
856                            );
857                        let res = grpc.unary(method, req).await;
858                        Ok(res)
859                    };
860                    Box::pin(fut)
861                }
862                "/ddkrpc.DdkRpc/SendOffer" => {
863                    #[allow(non_camel_case_types)]
864                    struct SendOfferSvc<T: DdkRpc>(pub Arc<T>);
865                    impl<T: DdkRpc> tonic::server::UnaryService<super::SendOfferRequest>
866                    for SendOfferSvc<T> {
867                        type Response = super::SendOfferResponse;
868                        type Future = BoxFuture<
869                            tonic::Response<Self::Response>,
870                            tonic::Status,
871                        >;
872                        fn call(
873                            &mut self,
874                            request: tonic::Request<super::SendOfferRequest>,
875                        ) -> Self::Future {
876                            let inner = Arc::clone(&self.0);
877                            let fut = async move {
878                                <T as DdkRpc>::send_offer(&inner, request).await
879                            };
880                            Box::pin(fut)
881                        }
882                    }
883                    let accept_compression_encodings = self.accept_compression_encodings;
884                    let send_compression_encodings = self.send_compression_encodings;
885                    let max_decoding_message_size = self.max_decoding_message_size;
886                    let max_encoding_message_size = self.max_encoding_message_size;
887                    let inner = self.inner.clone();
888                    let fut = async move {
889                        let inner = inner.0;
890                        let method = SendOfferSvc(inner);
891                        let codec = tonic::codec::ProstCodec::default();
892                        let mut grpc = tonic::server::Grpc::new(codec)
893                            .apply_compression_config(
894                                accept_compression_encodings,
895                                send_compression_encodings,
896                            )
897                            .apply_max_message_size_config(
898                                max_decoding_message_size,
899                                max_encoding_message_size,
900                            );
901                        let res = grpc.unary(method, req).await;
902                        Ok(res)
903                    };
904                    Box::pin(fut)
905                }
906                "/ddkrpc.DdkRpc/AcceptOffer" => {
907                    #[allow(non_camel_case_types)]
908                    struct AcceptOfferSvc<T: DdkRpc>(pub Arc<T>);
909                    impl<
910                        T: DdkRpc,
911                    > tonic::server::UnaryService<super::AcceptOfferRequest>
912                    for AcceptOfferSvc<T> {
913                        type Response = super::AcceptOfferResponse;
914                        type Future = BoxFuture<
915                            tonic::Response<Self::Response>,
916                            tonic::Status,
917                        >;
918                        fn call(
919                            &mut self,
920                            request: tonic::Request<super::AcceptOfferRequest>,
921                        ) -> Self::Future {
922                            let inner = Arc::clone(&self.0);
923                            let fut = async move {
924                                <T as DdkRpc>::accept_offer(&inner, request).await
925                            };
926                            Box::pin(fut)
927                        }
928                    }
929                    let accept_compression_encodings = self.accept_compression_encodings;
930                    let send_compression_encodings = self.send_compression_encodings;
931                    let max_decoding_message_size = self.max_decoding_message_size;
932                    let max_encoding_message_size = self.max_encoding_message_size;
933                    let inner = self.inner.clone();
934                    let fut = async move {
935                        let inner = inner.0;
936                        let method = AcceptOfferSvc(inner);
937                        let codec = tonic::codec::ProstCodec::default();
938                        let mut grpc = tonic::server::Grpc::new(codec)
939                            .apply_compression_config(
940                                accept_compression_encodings,
941                                send_compression_encodings,
942                            )
943                            .apply_max_message_size_config(
944                                max_decoding_message_size,
945                                max_encoding_message_size,
946                            );
947                        let res = grpc.unary(method, req).await;
948                        Ok(res)
949                    };
950                    Box::pin(fut)
951                }
952                "/ddkrpc.DdkRpc/ListOffers" => {
953                    #[allow(non_camel_case_types)]
954                    struct ListOffersSvc<T: DdkRpc>(pub Arc<T>);
955                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListOffersRequest>
956                    for ListOffersSvc<T> {
957                        type Response = super::ListOffersResponse;
958                        type Future = BoxFuture<
959                            tonic::Response<Self::Response>,
960                            tonic::Status,
961                        >;
962                        fn call(
963                            &mut self,
964                            request: tonic::Request<super::ListOffersRequest>,
965                        ) -> Self::Future {
966                            let inner = Arc::clone(&self.0);
967                            let fut = async move {
968                                <T as DdkRpc>::list_offers(&inner, request).await
969                            };
970                            Box::pin(fut)
971                        }
972                    }
973                    let accept_compression_encodings = self.accept_compression_encodings;
974                    let send_compression_encodings = self.send_compression_encodings;
975                    let max_decoding_message_size = self.max_decoding_message_size;
976                    let max_encoding_message_size = self.max_encoding_message_size;
977                    let inner = self.inner.clone();
978                    let fut = async move {
979                        let inner = inner.0;
980                        let method = ListOffersSvc(inner);
981                        let codec = tonic::codec::ProstCodec::default();
982                        let mut grpc = tonic::server::Grpc::new(codec)
983                            .apply_compression_config(
984                                accept_compression_encodings,
985                                send_compression_encodings,
986                            )
987                            .apply_max_message_size_config(
988                                max_decoding_message_size,
989                                max_encoding_message_size,
990                            );
991                        let res = grpc.unary(method, req).await;
992                        Ok(res)
993                    };
994                    Box::pin(fut)
995                }
996                "/ddkrpc.DdkRpc/NewAddress" => {
997                    #[allow(non_camel_case_types)]
998                    struct NewAddressSvc<T: DdkRpc>(pub Arc<T>);
999                    impl<T: DdkRpc> tonic::server::UnaryService<super::NewAddressRequest>
1000                    for NewAddressSvc<T> {
1001                        type Response = super::NewAddressResponse;
1002                        type Future = BoxFuture<
1003                            tonic::Response<Self::Response>,
1004                            tonic::Status,
1005                        >;
1006                        fn call(
1007                            &mut self,
1008                            request: tonic::Request<super::NewAddressRequest>,
1009                        ) -> Self::Future {
1010                            let inner = Arc::clone(&self.0);
1011                            let fut = async move {
1012                                <T as DdkRpc>::new_address(&inner, request).await
1013                            };
1014                            Box::pin(fut)
1015                        }
1016                    }
1017                    let accept_compression_encodings = self.accept_compression_encodings;
1018                    let send_compression_encodings = self.send_compression_encodings;
1019                    let max_decoding_message_size = self.max_decoding_message_size;
1020                    let max_encoding_message_size = self.max_encoding_message_size;
1021                    let inner = self.inner.clone();
1022                    let fut = async move {
1023                        let inner = inner.0;
1024                        let method = NewAddressSvc(inner);
1025                        let codec = tonic::codec::ProstCodec::default();
1026                        let mut grpc = tonic::server::Grpc::new(codec)
1027                            .apply_compression_config(
1028                                accept_compression_encodings,
1029                                send_compression_encodings,
1030                            )
1031                            .apply_max_message_size_config(
1032                                max_decoding_message_size,
1033                                max_encoding_message_size,
1034                            );
1035                        let res = grpc.unary(method, req).await;
1036                        Ok(res)
1037                    };
1038                    Box::pin(fut)
1039                }
1040                "/ddkrpc.DdkRpc/WalletBalance" => {
1041                    #[allow(non_camel_case_types)]
1042                    struct WalletBalanceSvc<T: DdkRpc>(pub Arc<T>);
1043                    impl<
1044                        T: DdkRpc,
1045                    > tonic::server::UnaryService<super::WalletBalanceRequest>
1046                    for WalletBalanceSvc<T> {
1047                        type Response = super::WalletBalanceResponse;
1048                        type Future = BoxFuture<
1049                            tonic::Response<Self::Response>,
1050                            tonic::Status,
1051                        >;
1052                        fn call(
1053                            &mut self,
1054                            request: tonic::Request<super::WalletBalanceRequest>,
1055                        ) -> Self::Future {
1056                            let inner = Arc::clone(&self.0);
1057                            let fut = async move {
1058                                <T as DdkRpc>::wallet_balance(&inner, request).await
1059                            };
1060                            Box::pin(fut)
1061                        }
1062                    }
1063                    let accept_compression_encodings = self.accept_compression_encodings;
1064                    let send_compression_encodings = self.send_compression_encodings;
1065                    let max_decoding_message_size = self.max_decoding_message_size;
1066                    let max_encoding_message_size = self.max_encoding_message_size;
1067                    let inner = self.inner.clone();
1068                    let fut = async move {
1069                        let inner = inner.0;
1070                        let method = WalletBalanceSvc(inner);
1071                        let codec = tonic::codec::ProstCodec::default();
1072                        let mut grpc = tonic::server::Grpc::new(codec)
1073                            .apply_compression_config(
1074                                accept_compression_encodings,
1075                                send_compression_encodings,
1076                            )
1077                            .apply_max_message_size_config(
1078                                max_decoding_message_size,
1079                                max_encoding_message_size,
1080                            );
1081                        let res = grpc.unary(method, req).await;
1082                        Ok(res)
1083                    };
1084                    Box::pin(fut)
1085                }
1086                "/ddkrpc.DdkRpc/WalletSync" => {
1087                    #[allow(non_camel_case_types)]
1088                    struct WalletSyncSvc<T: DdkRpc>(pub Arc<T>);
1089                    impl<T: DdkRpc> tonic::server::UnaryService<super::WalletSyncRequest>
1090                    for WalletSyncSvc<T> {
1091                        type Response = super::WalletSyncResponse;
1092                        type Future = BoxFuture<
1093                            tonic::Response<Self::Response>,
1094                            tonic::Status,
1095                        >;
1096                        fn call(
1097                            &mut self,
1098                            request: tonic::Request<super::WalletSyncRequest>,
1099                        ) -> Self::Future {
1100                            let inner = Arc::clone(&self.0);
1101                            let fut = async move {
1102                                <T as DdkRpc>::wallet_sync(&inner, request).await
1103                            };
1104                            Box::pin(fut)
1105                        }
1106                    }
1107                    let accept_compression_encodings = self.accept_compression_encodings;
1108                    let send_compression_encodings = self.send_compression_encodings;
1109                    let max_decoding_message_size = self.max_decoding_message_size;
1110                    let max_encoding_message_size = self.max_encoding_message_size;
1111                    let inner = self.inner.clone();
1112                    let fut = async move {
1113                        let inner = inner.0;
1114                        let method = WalletSyncSvc(inner);
1115                        let codec = tonic::codec::ProstCodec::default();
1116                        let mut grpc = tonic::server::Grpc::new(codec)
1117                            .apply_compression_config(
1118                                accept_compression_encodings,
1119                                send_compression_encodings,
1120                            )
1121                            .apply_max_message_size_config(
1122                                max_decoding_message_size,
1123                                max_encoding_message_size,
1124                            );
1125                        let res = grpc.unary(method, req).await;
1126                        Ok(res)
1127                    };
1128                    Box::pin(fut)
1129                }
1130                "/ddkrpc.DdkRpc/GetWalletTransactions" => {
1131                    #[allow(non_camel_case_types)]
1132                    struct GetWalletTransactionsSvc<T: DdkRpc>(pub Arc<T>);
1133                    impl<
1134                        T: DdkRpc,
1135                    > tonic::server::UnaryService<super::GetWalletTransactionsRequest>
1136                    for GetWalletTransactionsSvc<T> {
1137                        type Response = super::GetWalletTransactionsResponse;
1138                        type Future = BoxFuture<
1139                            tonic::Response<Self::Response>,
1140                            tonic::Status,
1141                        >;
1142                        fn call(
1143                            &mut self,
1144                            request: tonic::Request<super::GetWalletTransactionsRequest>,
1145                        ) -> Self::Future {
1146                            let inner = Arc::clone(&self.0);
1147                            let fut = async move {
1148                                <T as DdkRpc>::get_wallet_transactions(&inner, request)
1149                                    .await
1150                            };
1151                            Box::pin(fut)
1152                        }
1153                    }
1154                    let accept_compression_encodings = self.accept_compression_encodings;
1155                    let send_compression_encodings = self.send_compression_encodings;
1156                    let max_decoding_message_size = self.max_decoding_message_size;
1157                    let max_encoding_message_size = self.max_encoding_message_size;
1158                    let inner = self.inner.clone();
1159                    let fut = async move {
1160                        let inner = inner.0;
1161                        let method = GetWalletTransactionsSvc(inner);
1162                        let codec = tonic::codec::ProstCodec::default();
1163                        let mut grpc = tonic::server::Grpc::new(codec)
1164                            .apply_compression_config(
1165                                accept_compression_encodings,
1166                                send_compression_encodings,
1167                            )
1168                            .apply_max_message_size_config(
1169                                max_decoding_message_size,
1170                                max_encoding_message_size,
1171                            );
1172                        let res = grpc.unary(method, req).await;
1173                        Ok(res)
1174                    };
1175                    Box::pin(fut)
1176                }
1177                "/ddkrpc.DdkRpc/ListUtxos" => {
1178                    #[allow(non_camel_case_types)]
1179                    struct ListUtxosSvc<T: DdkRpc>(pub Arc<T>);
1180                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListUtxosRequest>
1181                    for ListUtxosSvc<T> {
1182                        type Response = super::ListUtxosResponse;
1183                        type Future = BoxFuture<
1184                            tonic::Response<Self::Response>,
1185                            tonic::Status,
1186                        >;
1187                        fn call(
1188                            &mut self,
1189                            request: tonic::Request<super::ListUtxosRequest>,
1190                        ) -> Self::Future {
1191                            let inner = Arc::clone(&self.0);
1192                            let fut = async move {
1193                                <T as DdkRpc>::list_utxos(&inner, request).await
1194                            };
1195                            Box::pin(fut)
1196                        }
1197                    }
1198                    let accept_compression_encodings = self.accept_compression_encodings;
1199                    let send_compression_encodings = self.send_compression_encodings;
1200                    let max_decoding_message_size = self.max_decoding_message_size;
1201                    let max_encoding_message_size = self.max_encoding_message_size;
1202                    let inner = self.inner.clone();
1203                    let fut = async move {
1204                        let inner = inner.0;
1205                        let method = ListUtxosSvc(inner);
1206                        let codec = tonic::codec::ProstCodec::default();
1207                        let mut grpc = tonic::server::Grpc::new(codec)
1208                            .apply_compression_config(
1209                                accept_compression_encodings,
1210                                send_compression_encodings,
1211                            )
1212                            .apply_max_message_size_config(
1213                                max_decoding_message_size,
1214                                max_encoding_message_size,
1215                            );
1216                        let res = grpc.unary(method, req).await;
1217                        Ok(res)
1218                    };
1219                    Box::pin(fut)
1220                }
1221                "/ddkrpc.DdkRpc/ListPeers" => {
1222                    #[allow(non_camel_case_types)]
1223                    struct ListPeersSvc<T: DdkRpc>(pub Arc<T>);
1224                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListPeersRequest>
1225                    for ListPeersSvc<T> {
1226                        type Response = super::ListPeersResponse;
1227                        type Future = BoxFuture<
1228                            tonic::Response<Self::Response>,
1229                            tonic::Status,
1230                        >;
1231                        fn call(
1232                            &mut self,
1233                            request: tonic::Request<super::ListPeersRequest>,
1234                        ) -> Self::Future {
1235                            let inner = Arc::clone(&self.0);
1236                            let fut = async move {
1237                                <T as DdkRpc>::list_peers(&inner, request).await
1238                            };
1239                            Box::pin(fut)
1240                        }
1241                    }
1242                    let accept_compression_encodings = self.accept_compression_encodings;
1243                    let send_compression_encodings = self.send_compression_encodings;
1244                    let max_decoding_message_size = self.max_decoding_message_size;
1245                    let max_encoding_message_size = self.max_encoding_message_size;
1246                    let inner = self.inner.clone();
1247                    let fut = async move {
1248                        let inner = inner.0;
1249                        let method = ListPeersSvc(inner);
1250                        let codec = tonic::codec::ProstCodec::default();
1251                        let mut grpc = tonic::server::Grpc::new(codec)
1252                            .apply_compression_config(
1253                                accept_compression_encodings,
1254                                send_compression_encodings,
1255                            )
1256                            .apply_max_message_size_config(
1257                                max_decoding_message_size,
1258                                max_encoding_message_size,
1259                            );
1260                        let res = grpc.unary(method, req).await;
1261                        Ok(res)
1262                    };
1263                    Box::pin(fut)
1264                }
1265                "/ddkrpc.DdkRpc/ConnectPeer" => {
1266                    #[allow(non_camel_case_types)]
1267                    struct ConnectPeerSvc<T: DdkRpc>(pub Arc<T>);
1268                    impl<T: DdkRpc> tonic::server::UnaryService<super::ConnectRequest>
1269                    for ConnectPeerSvc<T> {
1270                        type Response = super::ConnectResponse;
1271                        type Future = BoxFuture<
1272                            tonic::Response<Self::Response>,
1273                            tonic::Status,
1274                        >;
1275                        fn call(
1276                            &mut self,
1277                            request: tonic::Request<super::ConnectRequest>,
1278                        ) -> Self::Future {
1279                            let inner = Arc::clone(&self.0);
1280                            let fut = async move {
1281                                <T as DdkRpc>::connect_peer(&inner, request).await
1282                            };
1283                            Box::pin(fut)
1284                        }
1285                    }
1286                    let accept_compression_encodings = self.accept_compression_encodings;
1287                    let send_compression_encodings = self.send_compression_encodings;
1288                    let max_decoding_message_size = self.max_decoding_message_size;
1289                    let max_encoding_message_size = self.max_encoding_message_size;
1290                    let inner = self.inner.clone();
1291                    let fut = async move {
1292                        let inner = inner.0;
1293                        let method = ConnectPeerSvc(inner);
1294                        let codec = tonic::codec::ProstCodec::default();
1295                        let mut grpc = tonic::server::Grpc::new(codec)
1296                            .apply_compression_config(
1297                                accept_compression_encodings,
1298                                send_compression_encodings,
1299                            )
1300                            .apply_max_message_size_config(
1301                                max_decoding_message_size,
1302                                max_encoding_message_size,
1303                            );
1304                        let res = grpc.unary(method, req).await;
1305                        Ok(res)
1306                    };
1307                    Box::pin(fut)
1308                }
1309                "/ddkrpc.DdkRpc/ListOracles" => {
1310                    #[allow(non_camel_case_types)]
1311                    struct ListOraclesSvc<T: DdkRpc>(pub Arc<T>);
1312                    impl<
1313                        T: DdkRpc,
1314                    > tonic::server::UnaryService<super::ListOraclesRequest>
1315                    for ListOraclesSvc<T> {
1316                        type Response = super::ListOraclesResponse;
1317                        type Future = BoxFuture<
1318                            tonic::Response<Self::Response>,
1319                            tonic::Status,
1320                        >;
1321                        fn call(
1322                            &mut self,
1323                            request: tonic::Request<super::ListOraclesRequest>,
1324                        ) -> Self::Future {
1325                            let inner = Arc::clone(&self.0);
1326                            let fut = async move {
1327                                <T as DdkRpc>::list_oracles(&inner, request).await
1328                            };
1329                            Box::pin(fut)
1330                        }
1331                    }
1332                    let accept_compression_encodings = self.accept_compression_encodings;
1333                    let send_compression_encodings = self.send_compression_encodings;
1334                    let max_decoding_message_size = self.max_decoding_message_size;
1335                    let max_encoding_message_size = self.max_encoding_message_size;
1336                    let inner = self.inner.clone();
1337                    let fut = async move {
1338                        let inner = inner.0;
1339                        let method = ListOraclesSvc(inner);
1340                        let codec = tonic::codec::ProstCodec::default();
1341                        let mut grpc = tonic::server::Grpc::new(codec)
1342                            .apply_compression_config(
1343                                accept_compression_encodings,
1344                                send_compression_encodings,
1345                            )
1346                            .apply_max_message_size_config(
1347                                max_decoding_message_size,
1348                                max_encoding_message_size,
1349                            );
1350                        let res = grpc.unary(method, req).await;
1351                        Ok(res)
1352                    };
1353                    Box::pin(fut)
1354                }
1355                "/ddkrpc.DdkRpc/ListContracts" => {
1356                    #[allow(non_camel_case_types)]
1357                    struct ListContractsSvc<T: DdkRpc>(pub Arc<T>);
1358                    impl<
1359                        T: DdkRpc,
1360                    > tonic::server::UnaryService<super::ListContractsRequest>
1361                    for ListContractsSvc<T> {
1362                        type Response = super::ListContractsResponse;
1363                        type Future = BoxFuture<
1364                            tonic::Response<Self::Response>,
1365                            tonic::Status,
1366                        >;
1367                        fn call(
1368                            &mut self,
1369                            request: tonic::Request<super::ListContractsRequest>,
1370                        ) -> Self::Future {
1371                            let inner = Arc::clone(&self.0);
1372                            let fut = async move {
1373                                <T as DdkRpc>::list_contracts(&inner, request).await
1374                            };
1375                            Box::pin(fut)
1376                        }
1377                    }
1378                    let accept_compression_encodings = self.accept_compression_encodings;
1379                    let send_compression_encodings = self.send_compression_encodings;
1380                    let max_decoding_message_size = self.max_decoding_message_size;
1381                    let max_encoding_message_size = self.max_encoding_message_size;
1382                    let inner = self.inner.clone();
1383                    let fut = async move {
1384                        let inner = inner.0;
1385                        let method = ListContractsSvc(inner);
1386                        let codec = tonic::codec::ProstCodec::default();
1387                        let mut grpc = tonic::server::Grpc::new(codec)
1388                            .apply_compression_config(
1389                                accept_compression_encodings,
1390                                send_compression_encodings,
1391                            )
1392                            .apply_max_message_size_config(
1393                                max_decoding_message_size,
1394                                max_encoding_message_size,
1395                            );
1396                        let res = grpc.unary(method, req).await;
1397                        Ok(res)
1398                    };
1399                    Box::pin(fut)
1400                }
1401                "/ddkrpc.DdkRpc/Send" => {
1402                    #[allow(non_camel_case_types)]
1403                    struct SendSvc<T: DdkRpc>(pub Arc<T>);
1404                    impl<T: DdkRpc> tonic::server::UnaryService<super::SendRequest>
1405                    for SendSvc<T> {
1406                        type Response = super::SendResponse;
1407                        type Future = BoxFuture<
1408                            tonic::Response<Self::Response>,
1409                            tonic::Status,
1410                        >;
1411                        fn call(
1412                            &mut self,
1413                            request: tonic::Request<super::SendRequest>,
1414                        ) -> Self::Future {
1415                            let inner = Arc::clone(&self.0);
1416                            let fut = async move {
1417                                <T as DdkRpc>::send(&inner, request).await
1418                            };
1419                            Box::pin(fut)
1420                        }
1421                    }
1422                    let accept_compression_encodings = self.accept_compression_encodings;
1423                    let send_compression_encodings = self.send_compression_encodings;
1424                    let max_decoding_message_size = self.max_decoding_message_size;
1425                    let max_encoding_message_size = self.max_encoding_message_size;
1426                    let inner = self.inner.clone();
1427                    let fut = async move {
1428                        let inner = inner.0;
1429                        let method = SendSvc(inner);
1430                        let codec = tonic::codec::ProstCodec::default();
1431                        let mut grpc = tonic::server::Grpc::new(codec)
1432                            .apply_compression_config(
1433                                accept_compression_encodings,
1434                                send_compression_encodings,
1435                            )
1436                            .apply_max_message_size_config(
1437                                max_decoding_message_size,
1438                                max_encoding_message_size,
1439                            );
1440                        let res = grpc.unary(method, req).await;
1441                        Ok(res)
1442                    };
1443                    Box::pin(fut)
1444                }
1445                "/ddkrpc.DdkRpc/OracleAnnouncements" => {
1446                    #[allow(non_camel_case_types)]
1447                    struct OracleAnnouncementsSvc<T: DdkRpc>(pub Arc<T>);
1448                    impl<
1449                        T: DdkRpc,
1450                    > tonic::server::UnaryService<super::OracleAnnouncementsRequest>
1451                    for OracleAnnouncementsSvc<T> {
1452                        type Response = super::OracleAnnouncementsResponse;
1453                        type Future = BoxFuture<
1454                            tonic::Response<Self::Response>,
1455                            tonic::Status,
1456                        >;
1457                        fn call(
1458                            &mut self,
1459                            request: tonic::Request<super::OracleAnnouncementsRequest>,
1460                        ) -> Self::Future {
1461                            let inner = Arc::clone(&self.0);
1462                            let fut = async move {
1463                                <T as DdkRpc>::oracle_announcements(&inner, request).await
1464                            };
1465                            Box::pin(fut)
1466                        }
1467                    }
1468                    let accept_compression_encodings = self.accept_compression_encodings;
1469                    let send_compression_encodings = self.send_compression_encodings;
1470                    let max_decoding_message_size = self.max_decoding_message_size;
1471                    let max_encoding_message_size = self.max_encoding_message_size;
1472                    let inner = self.inner.clone();
1473                    let fut = async move {
1474                        let inner = inner.0;
1475                        let method = OracleAnnouncementsSvc(inner);
1476                        let codec = tonic::codec::ProstCodec::default();
1477                        let mut grpc = tonic::server::Grpc::new(codec)
1478                            .apply_compression_config(
1479                                accept_compression_encodings,
1480                                send_compression_encodings,
1481                            )
1482                            .apply_max_message_size_config(
1483                                max_decoding_message_size,
1484                                max_encoding_message_size,
1485                            );
1486                        let res = grpc.unary(method, req).await;
1487                        Ok(res)
1488                    };
1489                    Box::pin(fut)
1490                }
1491                _ => {
1492                    Box::pin(async move {
1493                        Ok(
1494                            http::Response::builder()
1495                                .status(200)
1496                                .header("grpc-status", "12")
1497                                .header("content-type", "application/grpc")
1498                                .body(empty_body())
1499                                .unwrap(),
1500                        )
1501                    })
1502                }
1503            }
1504        }
1505    }
1506    impl<T: DdkRpc> Clone for DdkRpcServer<T> {
1507        fn clone(&self) -> Self {
1508            let inner = self.inner.clone();
1509            Self {
1510                inner,
1511                accept_compression_encodings: self.accept_compression_encodings,
1512                send_compression_encodings: self.send_compression_encodings,
1513                max_decoding_message_size: self.max_decoding_message_size,
1514                max_encoding_message_size: self.max_encoding_message_size,
1515            }
1516        }
1517    }
1518    impl<T: DdkRpc> Clone for _Inner<T> {
1519        fn clone(&self) -> Self {
1520            Self(Arc::clone(&self.0))
1521        }
1522    }
1523    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
1524        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1525            write!(f, "{:?}", self.0)
1526        }
1527    }
1528    impl<T: DdkRpc> tonic::server::NamedService for DdkRpcServer<T> {
1529        const NAME: &'static str = "ddkrpc.DdkRpc";
1530    }
1531}
ddk_node/ddkrpc.rs

ddk_node/
ddkrpc.rs
