Skip to main content

ddk_node/
ddkrpc.rs

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