1#[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 #[prost(string, tag = "1")]
192 pub event_id: ::prost::alloc::string::String,
193}
194#[derive(serde::Serialize, serde::Deserialize)]
195#[allow(clippy::derive_partial_eq_without_eq)]
196#[derive(Clone, PartialEq, ::prost::Message)]
197pub struct OracleAnnouncementsResponse {
198 #[prost(bytes = "vec", tag = "1")]
199 pub announcement: ::prost::alloc::vec::Vec<u8>,
200}
201#[derive(serde::Serialize, serde::Deserialize)]
202#[allow(clippy::derive_partial_eq_without_eq)]
203#[derive(Clone, PartialEq, ::prost::Message)]
204pub struct WalletSyncRequest {}
205#[derive(serde::Serialize, serde::Deserialize)]
206#[allow(clippy::derive_partial_eq_without_eq)]
207#[derive(Clone, PartialEq, ::prost::Message)]
208pub struct WalletSyncResponse {}
209#[derive(serde::Serialize, serde::Deserialize)]
210#[allow(clippy::derive_partial_eq_without_eq)]
211#[derive(Clone, PartialEq, ::prost::Message)]
212pub struct SyncRequest {}
213#[derive(serde::Serialize, serde::Deserialize)]
214#[allow(clippy::derive_partial_eq_without_eq)]
215#[derive(Clone, PartialEq, ::prost::Message)]
216pub struct SyncResponse {}
217#[derive(serde::Serialize, serde::Deserialize)]
218#[allow(clippy::derive_partial_eq_without_eq)]
219#[derive(Clone, PartialEq, ::prost::Message)]
220pub struct CreateEnumRequest {
221 #[prost(uint32, tag = "1")]
222 pub maturity: u32,
223 #[prost(string, repeated, tag = "2")]
224 pub outcomes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
225}
226#[derive(serde::Serialize, serde::Deserialize)]
227#[allow(clippy::derive_partial_eq_without_eq)]
228#[derive(Clone, PartialEq, ::prost::Message)]
229pub struct CreateEnumResponse {
230 #[prost(bytes = "vec", tag = "1")]
231 pub announcement: ::prost::alloc::vec::Vec<u8>,
232}
233pub mod ddk_rpc_client {
235 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
236 use tonic::codegen::*;
237 use tonic::codegen::http::Uri;
238 #[derive(Debug, Clone)]
239 pub struct DdkRpcClient<T> {
240 inner: tonic::client::Grpc<T>,
241 }
242 impl DdkRpcClient<tonic::transport::Channel> {
243 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
245 where
246 D: TryInto<tonic::transport::Endpoint>,
247 D::Error: Into<StdError>,
248 {
249 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
250 Ok(Self::new(conn))
251 }
252 }
253 impl<T> DdkRpcClient<T>
254 where
255 T: tonic::client::GrpcService<tonic::body::BoxBody>,
256 T::Error: Into<StdError>,
257 T::ResponseBody: Body<Data = Bytes> + Send + 'static,
258 <T::ResponseBody as Body>::Error: Into<StdError> + Send,
259 {
260 pub fn new(inner: T) -> Self {
261 let inner = tonic::client::Grpc::new(inner);
262 Self { inner }
263 }
264 pub fn with_origin(inner: T, origin: Uri) -> Self {
265 let inner = tonic::client::Grpc::with_origin(inner, origin);
266 Self { inner }
267 }
268 pub fn with_interceptor<F>(
269 inner: T,
270 interceptor: F,
271 ) -> DdkRpcClient<InterceptedService<T, F>>
272 where
273 F: tonic::service::Interceptor,
274 T::ResponseBody: Default,
275 T: tonic::codegen::Service<
276 http::Request<tonic::body::BoxBody>,
277 Response = http::Response<
278 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
279 >,
280 >,
281 <T as tonic::codegen::Service<
282 http::Request<tonic::body::BoxBody>,
283 >>::Error: Into<StdError> + Send + Sync,
284 {
285 DdkRpcClient::new(InterceptedService::new(inner, interceptor))
286 }
287 #[must_use]
292 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
293 self.inner = self.inner.send_compressed(encoding);
294 self
295 }
296 #[must_use]
298 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
299 self.inner = self.inner.accept_compressed(encoding);
300 self
301 }
302 #[must_use]
306 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
307 self.inner = self.inner.max_decoding_message_size(limit);
308 self
309 }
310 #[must_use]
314 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
315 self.inner = self.inner.max_encoding_message_size(limit);
316 self
317 }
318 pub async fn info(
319 &mut self,
320 request: impl tonic::IntoRequest<super::InfoRequest>,
321 ) -> std::result::Result<tonic::Response<super::InfoResponse>, tonic::Status> {
322 self.inner
323 .ready()
324 .await
325 .map_err(|e| {
326 tonic::Status::new(
327 tonic::Code::Unknown,
328 format!("Service was not ready: {}", e.into()),
329 )
330 })?;
331 let codec = tonic::codec::ProstCodec::default();
332 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Info");
333 let mut req = request.into_request();
334 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Info"));
335 self.inner.unary(req, path, codec).await
336 }
337 pub async fn send_offer(
338 &mut self,
339 request: impl tonic::IntoRequest<super::SendOfferRequest>,
340 ) -> std::result::Result<
341 tonic::Response<super::SendOfferResponse>,
342 tonic::Status,
343 > {
344 self.inner
345 .ready()
346 .await
347 .map_err(|e| {
348 tonic::Status::new(
349 tonic::Code::Unknown,
350 format!("Service was not ready: {}", e.into()),
351 )
352 })?;
353 let codec = tonic::codec::ProstCodec::default();
354 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/SendOffer");
355 let mut req = request.into_request();
356 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "SendOffer"));
357 self.inner.unary(req, path, codec).await
358 }
359 pub async fn accept_offer(
360 &mut self,
361 request: impl tonic::IntoRequest<super::AcceptOfferRequest>,
362 ) -> std::result::Result<
363 tonic::Response<super::AcceptOfferResponse>,
364 tonic::Status,
365 > {
366 self.inner
367 .ready()
368 .await
369 .map_err(|e| {
370 tonic::Status::new(
371 tonic::Code::Unknown,
372 format!("Service was not ready: {}", e.into()),
373 )
374 })?;
375 let codec = tonic::codec::ProstCodec::default();
376 let path = http::uri::PathAndQuery::from_static(
377 "/ddkrpc.DdkRpc/AcceptOffer",
378 );
379 let mut req = request.into_request();
380 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "AcceptOffer"));
381 self.inner.unary(req, path, codec).await
382 }
383 pub async fn list_offers(
384 &mut self,
385 request: impl tonic::IntoRequest<super::ListOffersRequest>,
386 ) -> std::result::Result<
387 tonic::Response<super::ListOffersResponse>,
388 tonic::Status,
389 > {
390 self.inner
391 .ready()
392 .await
393 .map_err(|e| {
394 tonic::Status::new(
395 tonic::Code::Unknown,
396 format!("Service was not ready: {}", e.into()),
397 )
398 })?;
399 let codec = tonic::codec::ProstCodec::default();
400 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListOffers");
401 let mut req = request.into_request();
402 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOffers"));
403 self.inner.unary(req, path, codec).await
404 }
405 pub async fn new_address(
406 &mut self,
407 request: impl tonic::IntoRequest<super::NewAddressRequest>,
408 ) -> std::result::Result<
409 tonic::Response<super::NewAddressResponse>,
410 tonic::Status,
411 > {
412 self.inner
413 .ready()
414 .await
415 .map_err(|e| {
416 tonic::Status::new(
417 tonic::Code::Unknown,
418 format!("Service was not ready: {}", e.into()),
419 )
420 })?;
421 let codec = tonic::codec::ProstCodec::default();
422 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/NewAddress");
423 let mut req = request.into_request();
424 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "NewAddress"));
425 self.inner.unary(req, path, codec).await
426 }
427 pub async fn wallet_balance(
428 &mut self,
429 request: impl tonic::IntoRequest<super::WalletBalanceRequest>,
430 ) -> std::result::Result<
431 tonic::Response<super::WalletBalanceResponse>,
432 tonic::Status,
433 > {
434 self.inner
435 .ready()
436 .await
437 .map_err(|e| {
438 tonic::Status::new(
439 tonic::Code::Unknown,
440 format!("Service was not ready: {}", e.into()),
441 )
442 })?;
443 let codec = tonic::codec::ProstCodec::default();
444 let path = http::uri::PathAndQuery::from_static(
445 "/ddkrpc.DdkRpc/WalletBalance",
446 );
447 let mut req = request.into_request();
448 req.extensions_mut()
449 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "WalletBalance"));
450 self.inner.unary(req, path, codec).await
451 }
452 pub async fn wallet_sync(
453 &mut self,
454 request: impl tonic::IntoRequest<super::WalletSyncRequest>,
455 ) -> std::result::Result<
456 tonic::Response<super::WalletSyncResponse>,
457 tonic::Status,
458 > {
459 self.inner
460 .ready()
461 .await
462 .map_err(|e| {
463 tonic::Status::new(
464 tonic::Code::Unknown,
465 format!("Service was not ready: {}", e.into()),
466 )
467 })?;
468 let codec = tonic::codec::ProstCodec::default();
469 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/WalletSync");
470 let mut req = request.into_request();
471 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "WalletSync"));
472 self.inner.unary(req, path, codec).await
473 }
474 pub async fn sync(
475 &mut self,
476 request: impl tonic::IntoRequest<super::SyncRequest>,
477 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> {
478 self.inner
479 .ready()
480 .await
481 .map_err(|e| {
482 tonic::Status::new(
483 tonic::Code::Unknown,
484 format!("Service was not ready: {}", e.into()),
485 )
486 })?;
487 let codec = tonic::codec::ProstCodec::default();
488 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Sync");
489 let mut req = request.into_request();
490 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Sync"));
491 self.inner.unary(req, path, codec).await
492 }
493 pub async fn get_wallet_transactions(
494 &mut self,
495 request: impl tonic::IntoRequest<super::GetWalletTransactionsRequest>,
496 ) -> std::result::Result<
497 tonic::Response<super::GetWalletTransactionsResponse>,
498 tonic::Status,
499 > {
500 self.inner
501 .ready()
502 .await
503 .map_err(|e| {
504 tonic::Status::new(
505 tonic::Code::Unknown,
506 format!("Service was not ready: {}", e.into()),
507 )
508 })?;
509 let codec = tonic::codec::ProstCodec::default();
510 let path = http::uri::PathAndQuery::from_static(
511 "/ddkrpc.DdkRpc/GetWalletTransactions",
512 );
513 let mut req = request.into_request();
514 req.extensions_mut()
515 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "GetWalletTransactions"));
516 self.inner.unary(req, path, codec).await
517 }
518 pub async fn list_utxos(
519 &mut self,
520 request: impl tonic::IntoRequest<super::ListUtxosRequest>,
521 ) -> std::result::Result<
522 tonic::Response<super::ListUtxosResponse>,
523 tonic::Status,
524 > {
525 self.inner
526 .ready()
527 .await
528 .map_err(|e| {
529 tonic::Status::new(
530 tonic::Code::Unknown,
531 format!("Service was not ready: {}", e.into()),
532 )
533 })?;
534 let codec = tonic::codec::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::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("/ddkrpc.DdkRpc/ListPeers");
558 let mut req = request.into_request();
559 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListPeers"));
560 self.inner.unary(req, path, codec).await
561 }
562 pub async fn connect_peer(
563 &mut self,
564 request: impl tonic::IntoRequest<super::ConnectRequest>,
565 ) -> std::result::Result<
566 tonic::Response<super::ConnectResponse>,
567 tonic::Status,
568 > {
569 self.inner
570 .ready()
571 .await
572 .map_err(|e| {
573 tonic::Status::new(
574 tonic::Code::Unknown,
575 format!("Service was not ready: {}", e.into()),
576 )
577 })?;
578 let codec = tonic::codec::ProstCodec::default();
579 let path = http::uri::PathAndQuery::from_static(
580 "/ddkrpc.DdkRpc/ConnectPeer",
581 );
582 let mut req = request.into_request();
583 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ConnectPeer"));
584 self.inner.unary(req, path, codec).await
585 }
586 pub async fn list_oracles(
587 &mut self,
588 request: impl tonic::IntoRequest<super::ListOraclesRequest>,
589 ) -> std::result::Result<
590 tonic::Response<super::ListOraclesResponse>,
591 tonic::Status,
592 > {
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(
604 "/ddkrpc.DdkRpc/ListOracles",
605 );
606 let mut req = request.into_request();
607 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOracles"));
608 self.inner.unary(req, path, codec).await
609 }
610 pub async fn list_contracts(
611 &mut self,
612 request: impl tonic::IntoRequest<super::ListContractsRequest>,
613 ) -> std::result::Result<
614 tonic::Response<super::ListContractsResponse>,
615 tonic::Status,
616 > {
617 self.inner
618 .ready()
619 .await
620 .map_err(|e| {
621 tonic::Status::new(
622 tonic::Code::Unknown,
623 format!("Service was not ready: {}", e.into()),
624 )
625 })?;
626 let codec = tonic::codec::ProstCodec::default();
627 let path = http::uri::PathAndQuery::from_static(
628 "/ddkrpc.DdkRpc/ListContracts",
629 );
630 let mut req = request.into_request();
631 req.extensions_mut()
632 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListContracts"));
633 self.inner.unary(req, path, codec).await
634 }
635 pub async fn send(
636 &mut self,
637 request: impl tonic::IntoRequest<super::SendRequest>,
638 ) -> std::result::Result<tonic::Response<super::SendResponse>, tonic::Status> {
639 self.inner
640 .ready()
641 .await
642 .map_err(|e| {
643 tonic::Status::new(
644 tonic::Code::Unknown,
645 format!("Service was not ready: {}", e.into()),
646 )
647 })?;
648 let codec = tonic::codec::ProstCodec::default();
649 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Send");
650 let mut req = request.into_request();
651 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Send"));
652 self.inner.unary(req, path, codec).await
653 }
654 pub async fn oracle_announcements(
655 &mut self,
656 request: impl tonic::IntoRequest<super::OracleAnnouncementsRequest>,
657 ) -> std::result::Result<
658 tonic::Response<super::OracleAnnouncementsResponse>,
659 tonic::Status,
660 > {
661 self.inner
662 .ready()
663 .await
664 .map_err(|e| {
665 tonic::Status::new(
666 tonic::Code::Unknown,
667 format!("Service was not ready: {}", e.into()),
668 )
669 })?;
670 let codec = tonic::codec::ProstCodec::default();
671 let path = http::uri::PathAndQuery::from_static(
672 "/ddkrpc.DdkRpc/OracleAnnouncements",
673 );
674 let mut req = request.into_request();
675 req.extensions_mut()
676 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "OracleAnnouncements"));
677 self.inner.unary(req, path, codec).await
678 }
679 pub async fn create_enum(
680 &mut self,
681 request: impl tonic::IntoRequest<super::CreateEnumRequest>,
682 ) -> std::result::Result<
683 tonic::Response<super::CreateEnumResponse>,
684 tonic::Status,
685 > {
686 self.inner
687 .ready()
688 .await
689 .map_err(|e| {
690 tonic::Status::new(
691 tonic::Code::Unknown,
692 format!("Service was not ready: {}", e.into()),
693 )
694 })?;
695 let codec = tonic::codec::ProstCodec::default();
696 let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/CreateEnum");
697 let mut req = request.into_request();
698 req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "CreateEnum"));
699 self.inner.unary(req, path, codec).await
700 }
701 }
702}
703pub mod ddk_rpc_server {
705 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
706 use tonic::codegen::*;
707 #[async_trait]
709 pub trait DdkRpc: Send + Sync + 'static {
710 async fn info(
711 &self,
712 request: tonic::Request<super::InfoRequest>,
713 ) -> std::result::Result<tonic::Response<super::InfoResponse>, tonic::Status>;
714 async fn send_offer(
715 &self,
716 request: tonic::Request<super::SendOfferRequest>,
717 ) -> std::result::Result<
718 tonic::Response<super::SendOfferResponse>,
719 tonic::Status,
720 >;
721 async fn accept_offer(
722 &self,
723 request: tonic::Request<super::AcceptOfferRequest>,
724 ) -> std::result::Result<
725 tonic::Response<super::AcceptOfferResponse>,
726 tonic::Status,
727 >;
728 async fn list_offers(
729 &self,
730 request: tonic::Request<super::ListOffersRequest>,
731 ) -> std::result::Result<
732 tonic::Response<super::ListOffersResponse>,
733 tonic::Status,
734 >;
735 async fn new_address(
736 &self,
737 request: tonic::Request<super::NewAddressRequest>,
738 ) -> std::result::Result<
739 tonic::Response<super::NewAddressResponse>,
740 tonic::Status,
741 >;
742 async fn wallet_balance(
743 &self,
744 request: tonic::Request<super::WalletBalanceRequest>,
745 ) -> std::result::Result<
746 tonic::Response<super::WalletBalanceResponse>,
747 tonic::Status,
748 >;
749 async fn wallet_sync(
750 &self,
751 request: tonic::Request<super::WalletSyncRequest>,
752 ) -> std::result::Result<
753 tonic::Response<super::WalletSyncResponse>,
754 tonic::Status,
755 >;
756 async fn sync(
757 &self,
758 request: tonic::Request<super::SyncRequest>,
759 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status>;
760 async fn get_wallet_transactions(
761 &self,
762 request: tonic::Request<super::GetWalletTransactionsRequest>,
763 ) -> std::result::Result<
764 tonic::Response<super::GetWalletTransactionsResponse>,
765 tonic::Status,
766 >;
767 async fn list_utxos(
768 &self,
769 request: tonic::Request<super::ListUtxosRequest>,
770 ) -> std::result::Result<
771 tonic::Response<super::ListUtxosResponse>,
772 tonic::Status,
773 >;
774 async fn list_peers(
775 &self,
776 request: tonic::Request<super::ListPeersRequest>,
777 ) -> std::result::Result<
778 tonic::Response<super::ListPeersResponse>,
779 tonic::Status,
780 >;
781 async fn connect_peer(
782 &self,
783 request: tonic::Request<super::ConnectRequest>,
784 ) -> std::result::Result<tonic::Response<super::ConnectResponse>, tonic::Status>;
785 async fn list_oracles(
786 &self,
787 request: tonic::Request<super::ListOraclesRequest>,
788 ) -> std::result::Result<
789 tonic::Response<super::ListOraclesResponse>,
790 tonic::Status,
791 >;
792 async fn list_contracts(
793 &self,
794 request: tonic::Request<super::ListContractsRequest>,
795 ) -> std::result::Result<
796 tonic::Response<super::ListContractsResponse>,
797 tonic::Status,
798 >;
799 async fn send(
800 &self,
801 request: tonic::Request<super::SendRequest>,
802 ) -> std::result::Result<tonic::Response<super::SendResponse>, tonic::Status>;
803 async fn oracle_announcements(
804 &self,
805 request: tonic::Request<super::OracleAnnouncementsRequest>,
806 ) -> std::result::Result<
807 tonic::Response<super::OracleAnnouncementsResponse>,
808 tonic::Status,
809 >;
810 async fn create_enum(
811 &self,
812 request: tonic::Request<super::CreateEnumRequest>,
813 ) -> std::result::Result<
814 tonic::Response<super::CreateEnumResponse>,
815 tonic::Status,
816 >;
817 }
818 #[derive(Debug)]
819 pub struct DdkRpcServer<T: DdkRpc> {
820 inner: _Inner<T>,
821 accept_compression_encodings: EnabledCompressionEncodings,
822 send_compression_encodings: EnabledCompressionEncodings,
823 max_decoding_message_size: Option<usize>,
824 max_encoding_message_size: Option<usize>,
825 }
826 struct _Inner<T>(Arc<T>);
827 impl<T: DdkRpc> DdkRpcServer<T> {
828 pub fn new(inner: T) -> Self {
829 Self::from_arc(Arc::new(inner))
830 }
831 pub fn from_arc(inner: Arc<T>) -> Self {
832 let inner = _Inner(inner);
833 Self {
834 inner,
835 accept_compression_encodings: Default::default(),
836 send_compression_encodings: Default::default(),
837 max_decoding_message_size: None,
838 max_encoding_message_size: None,
839 }
840 }
841 pub fn with_interceptor<F>(
842 inner: T,
843 interceptor: F,
844 ) -> InterceptedService<Self, F>
845 where
846 F: tonic::service::Interceptor,
847 {
848 InterceptedService::new(Self::new(inner), interceptor)
849 }
850 #[must_use]
852 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
853 self.accept_compression_encodings.enable(encoding);
854 self
855 }
856 #[must_use]
858 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
859 self.send_compression_encodings.enable(encoding);
860 self
861 }
862 #[must_use]
866 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
867 self.max_decoding_message_size = Some(limit);
868 self
869 }
870 #[must_use]
874 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
875 self.max_encoding_message_size = Some(limit);
876 self
877 }
878 }
879 impl<T, B> tonic::codegen::Service<http::Request<B>> for DdkRpcServer<T>
880 where
881 T: DdkRpc,
882 B: Body + Send + 'static,
883 B::Error: Into<StdError> + Send + 'static,
884 {
885 type Response = http::Response<tonic::body::BoxBody>;
886 type Error = std::convert::Infallible;
887 type Future = BoxFuture<Self::Response, Self::Error>;
888 fn poll_ready(
889 &mut self,
890 _cx: &mut Context<'_>,
891 ) -> Poll<std::result::Result<(), Self::Error>> {
892 Poll::Ready(Ok(()))
893 }
894 fn call(&mut self, req: http::Request<B>) -> Self::Future {
895 let inner = self.inner.clone();
896 match req.uri().path() {
897 "/ddkrpc.DdkRpc/Info" => {
898 #[allow(non_camel_case_types)]
899 struct InfoSvc<T: DdkRpc>(pub Arc<T>);
900 impl<T: DdkRpc> tonic::server::UnaryService<super::InfoRequest>
901 for InfoSvc<T> {
902 type Response = super::InfoResponse;
903 type Future = BoxFuture<
904 tonic::Response<Self::Response>,
905 tonic::Status,
906 >;
907 fn call(
908 &mut self,
909 request: tonic::Request<super::InfoRequest>,
910 ) -> Self::Future {
911 let inner = Arc::clone(&self.0);
912 let fut = async move {
913 <T as DdkRpc>::info(&inner, request).await
914 };
915 Box::pin(fut)
916 }
917 }
918 let accept_compression_encodings = self.accept_compression_encodings;
919 let send_compression_encodings = self.send_compression_encodings;
920 let max_decoding_message_size = self.max_decoding_message_size;
921 let max_encoding_message_size = self.max_encoding_message_size;
922 let inner = self.inner.clone();
923 let fut = async move {
924 let inner = inner.0;
925 let method = InfoSvc(inner);
926 let codec = tonic::codec::ProstCodec::default();
927 let mut grpc = tonic::server::Grpc::new(codec)
928 .apply_compression_config(
929 accept_compression_encodings,
930 send_compression_encodings,
931 )
932 .apply_max_message_size_config(
933 max_decoding_message_size,
934 max_encoding_message_size,
935 );
936 let res = grpc.unary(method, req).await;
937 Ok(res)
938 };
939 Box::pin(fut)
940 }
941 "/ddkrpc.DdkRpc/SendOffer" => {
942 #[allow(non_camel_case_types)]
943 struct SendOfferSvc<T: DdkRpc>(pub Arc<T>);
944 impl<T: DdkRpc> tonic::server::UnaryService<super::SendOfferRequest>
945 for SendOfferSvc<T> {
946 type Response = super::SendOfferResponse;
947 type Future = BoxFuture<
948 tonic::Response<Self::Response>,
949 tonic::Status,
950 >;
951 fn call(
952 &mut self,
953 request: tonic::Request<super::SendOfferRequest>,
954 ) -> Self::Future {
955 let inner = Arc::clone(&self.0);
956 let fut = async move {
957 <T as DdkRpc>::send_offer(&inner, request).await
958 };
959 Box::pin(fut)
960 }
961 }
962 let accept_compression_encodings = self.accept_compression_encodings;
963 let send_compression_encodings = self.send_compression_encodings;
964 let max_decoding_message_size = self.max_decoding_message_size;
965 let max_encoding_message_size = self.max_encoding_message_size;
966 let inner = self.inner.clone();
967 let fut = async move {
968 let inner = inner.0;
969 let method = SendOfferSvc(inner);
970 let codec = tonic::codec::ProstCodec::default();
971 let mut grpc = tonic::server::Grpc::new(codec)
972 .apply_compression_config(
973 accept_compression_encodings,
974 send_compression_encodings,
975 )
976 .apply_max_message_size_config(
977 max_decoding_message_size,
978 max_encoding_message_size,
979 );
980 let res = grpc.unary(method, req).await;
981 Ok(res)
982 };
983 Box::pin(fut)
984 }
985 "/ddkrpc.DdkRpc/AcceptOffer" => {
986 #[allow(non_camel_case_types)]
987 struct AcceptOfferSvc<T: DdkRpc>(pub Arc<T>);
988 impl<
989 T: DdkRpc,
990 > tonic::server::UnaryService<super::AcceptOfferRequest>
991 for AcceptOfferSvc<T> {
992 type Response = super::AcceptOfferResponse;
993 type Future = BoxFuture<
994 tonic::Response<Self::Response>,
995 tonic::Status,
996 >;
997 fn call(
998 &mut self,
999 request: tonic::Request<super::AcceptOfferRequest>,
1000 ) -> Self::Future {
1001 let inner = Arc::clone(&self.0);
1002 let fut = async move {
1003 <T as DdkRpc>::accept_offer(&inner, request).await
1004 };
1005 Box::pin(fut)
1006 }
1007 }
1008 let accept_compression_encodings = self.accept_compression_encodings;
1009 let send_compression_encodings = self.send_compression_encodings;
1010 let max_decoding_message_size = self.max_decoding_message_size;
1011 let max_encoding_message_size = self.max_encoding_message_size;
1012 let inner = self.inner.clone();
1013 let fut = async move {
1014 let inner = inner.0;
1015 let method = AcceptOfferSvc(inner);
1016 let codec = tonic::codec::ProstCodec::default();
1017 let mut grpc = tonic::server::Grpc::new(codec)
1018 .apply_compression_config(
1019 accept_compression_encodings,
1020 send_compression_encodings,
1021 )
1022 .apply_max_message_size_config(
1023 max_decoding_message_size,
1024 max_encoding_message_size,
1025 );
1026 let res = grpc.unary(method, req).await;
1027 Ok(res)
1028 };
1029 Box::pin(fut)
1030 }
1031 "/ddkrpc.DdkRpc/ListOffers" => {
1032 #[allow(non_camel_case_types)]
1033 struct ListOffersSvc<T: DdkRpc>(pub Arc<T>);
1034 impl<T: DdkRpc> tonic::server::UnaryService<super::ListOffersRequest>
1035 for ListOffersSvc<T> {
1036 type Response = super::ListOffersResponse;
1037 type Future = BoxFuture<
1038 tonic::Response<Self::Response>,
1039 tonic::Status,
1040 >;
1041 fn call(
1042 &mut self,
1043 request: tonic::Request<super::ListOffersRequest>,
1044 ) -> Self::Future {
1045 let inner = Arc::clone(&self.0);
1046 let fut = async move {
1047 <T as DdkRpc>::list_offers(&inner, request).await
1048 };
1049 Box::pin(fut)
1050 }
1051 }
1052 let accept_compression_encodings = self.accept_compression_encodings;
1053 let send_compression_encodings = self.send_compression_encodings;
1054 let max_decoding_message_size = self.max_decoding_message_size;
1055 let max_encoding_message_size = self.max_encoding_message_size;
1056 let inner = self.inner.clone();
1057 let fut = async move {
1058 let inner = inner.0;
1059 let method = ListOffersSvc(inner);
1060 let codec = tonic::codec::ProstCodec::default();
1061 let mut grpc = tonic::server::Grpc::new(codec)
1062 .apply_compression_config(
1063 accept_compression_encodings,
1064 send_compression_encodings,
1065 )
1066 .apply_max_message_size_config(
1067 max_decoding_message_size,
1068 max_encoding_message_size,
1069 );
1070 let res = grpc.unary(method, req).await;
1071 Ok(res)
1072 };
1073 Box::pin(fut)
1074 }
1075 "/ddkrpc.DdkRpc/NewAddress" => {
1076 #[allow(non_camel_case_types)]
1077 struct NewAddressSvc<T: DdkRpc>(pub Arc<T>);
1078 impl<T: DdkRpc> tonic::server::UnaryService<super::NewAddressRequest>
1079 for NewAddressSvc<T> {
1080 type Response = super::NewAddressResponse;
1081 type Future = BoxFuture<
1082 tonic::Response<Self::Response>,
1083 tonic::Status,
1084 >;
1085 fn call(
1086 &mut self,
1087 request: tonic::Request<super::NewAddressRequest>,
1088 ) -> Self::Future {
1089 let inner = Arc::clone(&self.0);
1090 let fut = async move {
1091 <T as DdkRpc>::new_address(&inner, request).await
1092 };
1093 Box::pin(fut)
1094 }
1095 }
1096 let accept_compression_encodings = self.accept_compression_encodings;
1097 let send_compression_encodings = self.send_compression_encodings;
1098 let max_decoding_message_size = self.max_decoding_message_size;
1099 let max_encoding_message_size = self.max_encoding_message_size;
1100 let inner = self.inner.clone();
1101 let fut = async move {
1102 let inner = inner.0;
1103 let method = NewAddressSvc(inner);
1104 let codec = tonic::codec::ProstCodec::default();
1105 let mut grpc = tonic::server::Grpc::new(codec)
1106 .apply_compression_config(
1107 accept_compression_encodings,
1108 send_compression_encodings,
1109 )
1110 .apply_max_message_size_config(
1111 max_decoding_message_size,
1112 max_encoding_message_size,
1113 );
1114 let res = grpc.unary(method, req).await;
1115 Ok(res)
1116 };
1117 Box::pin(fut)
1118 }
1119 "/ddkrpc.DdkRpc/WalletBalance" => {
1120 #[allow(non_camel_case_types)]
1121 struct WalletBalanceSvc<T: DdkRpc>(pub Arc<T>);
1122 impl<
1123 T: DdkRpc,
1124 > tonic::server::UnaryService<super::WalletBalanceRequest>
1125 for WalletBalanceSvc<T> {
1126 type Response = super::WalletBalanceResponse;
1127 type Future = BoxFuture<
1128 tonic::Response<Self::Response>,
1129 tonic::Status,
1130 >;
1131 fn call(
1132 &mut self,
1133 request: tonic::Request<super::WalletBalanceRequest>,
1134 ) -> Self::Future {
1135 let inner = Arc::clone(&self.0);
1136 let fut = async move {
1137 <T as DdkRpc>::wallet_balance(&inner, request).await
1138 };
1139 Box::pin(fut)
1140 }
1141 }
1142 let accept_compression_encodings = self.accept_compression_encodings;
1143 let send_compression_encodings = self.send_compression_encodings;
1144 let max_decoding_message_size = self.max_decoding_message_size;
1145 let max_encoding_message_size = self.max_encoding_message_size;
1146 let inner = self.inner.clone();
1147 let fut = async move {
1148 let inner = inner.0;
1149 let method = WalletBalanceSvc(inner);
1150 let codec = tonic::codec::ProstCodec::default();
1151 let mut grpc = tonic::server::Grpc::new(codec)
1152 .apply_compression_config(
1153 accept_compression_encodings,
1154 send_compression_encodings,
1155 )
1156 .apply_max_message_size_config(
1157 max_decoding_message_size,
1158 max_encoding_message_size,
1159 );
1160 let res = grpc.unary(method, req).await;
1161 Ok(res)
1162 };
1163 Box::pin(fut)
1164 }
1165 "/ddkrpc.DdkRpc/WalletSync" => {
1166 #[allow(non_camel_case_types)]
1167 struct WalletSyncSvc<T: DdkRpc>(pub Arc<T>);
1168 impl<T: DdkRpc> tonic::server::UnaryService<super::WalletSyncRequest>
1169 for WalletSyncSvc<T> {
1170 type Response = super::WalletSyncResponse;
1171 type Future = BoxFuture<
1172 tonic::Response<Self::Response>,
1173 tonic::Status,
1174 >;
1175 fn call(
1176 &mut self,
1177 request: tonic::Request<super::WalletSyncRequest>,
1178 ) -> Self::Future {
1179 let inner = Arc::clone(&self.0);
1180 let fut = async move {
1181 <T as DdkRpc>::wallet_sync(&inner, request).await
1182 };
1183 Box::pin(fut)
1184 }
1185 }
1186 let accept_compression_encodings = self.accept_compression_encodings;
1187 let send_compression_encodings = self.send_compression_encodings;
1188 let max_decoding_message_size = self.max_decoding_message_size;
1189 let max_encoding_message_size = self.max_encoding_message_size;
1190 let inner = self.inner.clone();
1191 let fut = async move {
1192 let inner = inner.0;
1193 let method = WalletSyncSvc(inner);
1194 let codec = tonic::codec::ProstCodec::default();
1195 let mut grpc = tonic::server::Grpc::new(codec)
1196 .apply_compression_config(
1197 accept_compression_encodings,
1198 send_compression_encodings,
1199 )
1200 .apply_max_message_size_config(
1201 max_decoding_message_size,
1202 max_encoding_message_size,
1203 );
1204 let res = grpc.unary(method, req).await;
1205 Ok(res)
1206 };
1207 Box::pin(fut)
1208 }
1209 "/ddkrpc.DdkRpc/Sync" => {
1210 #[allow(non_camel_case_types)]
1211 struct SyncSvc<T: DdkRpc>(pub Arc<T>);
1212 impl<T: DdkRpc> tonic::server::UnaryService<super::SyncRequest>
1213 for SyncSvc<T> {
1214 type Response = super::SyncResponse;
1215 type Future = BoxFuture<
1216 tonic::Response<Self::Response>,
1217 tonic::Status,
1218 >;
1219 fn call(
1220 &mut self,
1221 request: tonic::Request<super::SyncRequest>,
1222 ) -> Self::Future {
1223 let inner = Arc::clone(&self.0);
1224 let fut = async move {
1225 <T as DdkRpc>::sync(&inner, request).await
1226 };
1227 Box::pin(fut)
1228 }
1229 }
1230 let accept_compression_encodings = self.accept_compression_encodings;
1231 let send_compression_encodings = self.send_compression_encodings;
1232 let max_decoding_message_size = self.max_decoding_message_size;
1233 let max_encoding_message_size = self.max_encoding_message_size;
1234 let inner = self.inner.clone();
1235 let fut = async move {
1236 let inner = inner.0;
1237 let method = SyncSvc(inner);
1238 let codec = tonic::codec::ProstCodec::default();
1239 let mut grpc = tonic::server::Grpc::new(codec)
1240 .apply_compression_config(
1241 accept_compression_encodings,
1242 send_compression_encodings,
1243 )
1244 .apply_max_message_size_config(
1245 max_decoding_message_size,
1246 max_encoding_message_size,
1247 );
1248 let res = grpc.unary(method, req).await;
1249 Ok(res)
1250 };
1251 Box::pin(fut)
1252 }
1253 "/ddkrpc.DdkRpc/GetWalletTransactions" => {
1254 #[allow(non_camel_case_types)]
1255 struct GetWalletTransactionsSvc<T: DdkRpc>(pub Arc<T>);
1256 impl<
1257 T: DdkRpc,
1258 > tonic::server::UnaryService<super::GetWalletTransactionsRequest>
1259 for GetWalletTransactionsSvc<T> {
1260 type Response = super::GetWalletTransactionsResponse;
1261 type Future = BoxFuture<
1262 tonic::Response<Self::Response>,
1263 tonic::Status,
1264 >;
1265 fn call(
1266 &mut self,
1267 request: tonic::Request<super::GetWalletTransactionsRequest>,
1268 ) -> Self::Future {
1269 let inner = Arc::clone(&self.0);
1270 let fut = async move {
1271 <T as DdkRpc>::get_wallet_transactions(&inner, request)
1272 .await
1273 };
1274 Box::pin(fut)
1275 }
1276 }
1277 let accept_compression_encodings = self.accept_compression_encodings;
1278 let send_compression_encodings = self.send_compression_encodings;
1279 let max_decoding_message_size = self.max_decoding_message_size;
1280 let max_encoding_message_size = self.max_encoding_message_size;
1281 let inner = self.inner.clone();
1282 let fut = async move {
1283 let inner = inner.0;
1284 let method = GetWalletTransactionsSvc(inner);
1285 let codec = tonic::codec::ProstCodec::default();
1286 let mut grpc = tonic::server::Grpc::new(codec)
1287 .apply_compression_config(
1288 accept_compression_encodings,
1289 send_compression_encodings,
1290 )
1291 .apply_max_message_size_config(
1292 max_decoding_message_size,
1293 max_encoding_message_size,
1294 );
1295 let res = grpc.unary(method, req).await;
1296 Ok(res)
1297 };
1298 Box::pin(fut)
1299 }
1300 "/ddkrpc.DdkRpc/ListUtxos" => {
1301 #[allow(non_camel_case_types)]
1302 struct ListUtxosSvc<T: DdkRpc>(pub Arc<T>);
1303 impl<T: DdkRpc> tonic::server::UnaryService<super::ListUtxosRequest>
1304 for ListUtxosSvc<T> {
1305 type Response = super::ListUtxosResponse;
1306 type Future = BoxFuture<
1307 tonic::Response<Self::Response>,
1308 tonic::Status,
1309 >;
1310 fn call(
1311 &mut self,
1312 request: tonic::Request<super::ListUtxosRequest>,
1313 ) -> Self::Future {
1314 let inner = Arc::clone(&self.0);
1315 let fut = async move {
1316 <T as DdkRpc>::list_utxos(&inner, request).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 inner = inner.0;
1328 let method = ListUtxosSvc(inner);
1329 let codec = tonic::codec::ProstCodec::default();
1330 let mut grpc = tonic::server::Grpc::new(codec)
1331 .apply_compression_config(
1332 accept_compression_encodings,
1333 send_compression_encodings,
1334 )
1335 .apply_max_message_size_config(
1336 max_decoding_message_size,
1337 max_encoding_message_size,
1338 );
1339 let res = grpc.unary(method, req).await;
1340 Ok(res)
1341 };
1342 Box::pin(fut)
1343 }
1344 "/ddkrpc.DdkRpc/ListPeers" => {
1345 #[allow(non_camel_case_types)]
1346 struct ListPeersSvc<T: DdkRpc>(pub Arc<T>);
1347 impl<T: DdkRpc> tonic::server::UnaryService<super::ListPeersRequest>
1348 for ListPeersSvc<T> {
1349 type Response = super::ListPeersResponse;
1350 type Future = BoxFuture<
1351 tonic::Response<Self::Response>,
1352 tonic::Status,
1353 >;
1354 fn call(
1355 &mut self,
1356 request: tonic::Request<super::ListPeersRequest>,
1357 ) -> Self::Future {
1358 let inner = Arc::clone(&self.0);
1359 let fut = async move {
1360 <T as DdkRpc>::list_peers(&inner, request).await
1361 };
1362 Box::pin(fut)
1363 }
1364 }
1365 let accept_compression_encodings = self.accept_compression_encodings;
1366 let send_compression_encodings = self.send_compression_encodings;
1367 let max_decoding_message_size = self.max_decoding_message_size;
1368 let max_encoding_message_size = self.max_encoding_message_size;
1369 let inner = self.inner.clone();
1370 let fut = async move {
1371 let inner = inner.0;
1372 let method = ListPeersSvc(inner);
1373 let codec = tonic::codec::ProstCodec::default();
1374 let mut grpc = tonic::server::Grpc::new(codec)
1375 .apply_compression_config(
1376 accept_compression_encodings,
1377 send_compression_encodings,
1378 )
1379 .apply_max_message_size_config(
1380 max_decoding_message_size,
1381 max_encoding_message_size,
1382 );
1383 let res = grpc.unary(method, req).await;
1384 Ok(res)
1385 };
1386 Box::pin(fut)
1387 }
1388 "/ddkrpc.DdkRpc/ConnectPeer" => {
1389 #[allow(non_camel_case_types)]
1390 struct ConnectPeerSvc<T: DdkRpc>(pub Arc<T>);
1391 impl<T: DdkRpc> tonic::server::UnaryService<super::ConnectRequest>
1392 for ConnectPeerSvc<T> {
1393 type Response = super::ConnectResponse;
1394 type Future = BoxFuture<
1395 tonic::Response<Self::Response>,
1396 tonic::Status,
1397 >;
1398 fn call(
1399 &mut self,
1400 request: tonic::Request<super::ConnectRequest>,
1401 ) -> Self::Future {
1402 let inner = Arc::clone(&self.0);
1403 let fut = async move {
1404 <T as DdkRpc>::connect_peer(&inner, request).await
1405 };
1406 Box::pin(fut)
1407 }
1408 }
1409 let accept_compression_encodings = self.accept_compression_encodings;
1410 let send_compression_encodings = self.send_compression_encodings;
1411 let max_decoding_message_size = self.max_decoding_message_size;
1412 let max_encoding_message_size = self.max_encoding_message_size;
1413 let inner = self.inner.clone();
1414 let fut = async move {
1415 let inner = inner.0;
1416 let method = ConnectPeerSvc(inner);
1417 let codec = tonic::codec::ProstCodec::default();
1418 let mut grpc = tonic::server::Grpc::new(codec)
1419 .apply_compression_config(
1420 accept_compression_encodings,
1421 send_compression_encodings,
1422 )
1423 .apply_max_message_size_config(
1424 max_decoding_message_size,
1425 max_encoding_message_size,
1426 );
1427 let res = grpc.unary(method, req).await;
1428 Ok(res)
1429 };
1430 Box::pin(fut)
1431 }
1432 "/ddkrpc.DdkRpc/ListOracles" => {
1433 #[allow(non_camel_case_types)]
1434 struct ListOraclesSvc<T: DdkRpc>(pub Arc<T>);
1435 impl<
1436 T: DdkRpc,
1437 > tonic::server::UnaryService<super::ListOraclesRequest>
1438 for ListOraclesSvc<T> {
1439 type Response = super::ListOraclesResponse;
1440 type Future = BoxFuture<
1441 tonic::Response<Self::Response>,
1442 tonic::Status,
1443 >;
1444 fn call(
1445 &mut self,
1446 request: tonic::Request<super::ListOraclesRequest>,
1447 ) -> Self::Future {
1448 let inner = Arc::clone(&self.0);
1449 let fut = async move {
1450 <T as DdkRpc>::list_oracles(&inner, request).await
1451 };
1452 Box::pin(fut)
1453 }
1454 }
1455 let accept_compression_encodings = self.accept_compression_encodings;
1456 let send_compression_encodings = self.send_compression_encodings;
1457 let max_decoding_message_size = self.max_decoding_message_size;
1458 let max_encoding_message_size = self.max_encoding_message_size;
1459 let inner = self.inner.clone();
1460 let fut = async move {
1461 let inner = inner.0;
1462 let method = ListOraclesSvc(inner);
1463 let codec = tonic::codec::ProstCodec::default();
1464 let mut grpc = tonic::server::Grpc::new(codec)
1465 .apply_compression_config(
1466 accept_compression_encodings,
1467 send_compression_encodings,
1468 )
1469 .apply_max_message_size_config(
1470 max_decoding_message_size,
1471 max_encoding_message_size,
1472 );
1473 let res = grpc.unary(method, req).await;
1474 Ok(res)
1475 };
1476 Box::pin(fut)
1477 }
1478 "/ddkrpc.DdkRpc/ListContracts" => {
1479 #[allow(non_camel_case_types)]
1480 struct ListContractsSvc<T: DdkRpc>(pub Arc<T>);
1481 impl<
1482 T: DdkRpc,
1483 > tonic::server::UnaryService<super::ListContractsRequest>
1484 for ListContractsSvc<T> {
1485 type Response = super::ListContractsResponse;
1486 type Future = BoxFuture<
1487 tonic::Response<Self::Response>,
1488 tonic::Status,
1489 >;
1490 fn call(
1491 &mut self,
1492 request: tonic::Request<super::ListContractsRequest>,
1493 ) -> Self::Future {
1494 let inner = Arc::clone(&self.0);
1495 let fut = async move {
1496 <T as DdkRpc>::list_contracts(&inner, request).await
1497 };
1498 Box::pin(fut)
1499 }
1500 }
1501 let accept_compression_encodings = self.accept_compression_encodings;
1502 let send_compression_encodings = self.send_compression_encodings;
1503 let max_decoding_message_size = self.max_decoding_message_size;
1504 let max_encoding_message_size = self.max_encoding_message_size;
1505 let inner = self.inner.clone();
1506 let fut = async move {
1507 let inner = inner.0;
1508 let method = ListContractsSvc(inner);
1509 let codec = tonic::codec::ProstCodec::default();
1510 let mut grpc = tonic::server::Grpc::new(codec)
1511 .apply_compression_config(
1512 accept_compression_encodings,
1513 send_compression_encodings,
1514 )
1515 .apply_max_message_size_config(
1516 max_decoding_message_size,
1517 max_encoding_message_size,
1518 );
1519 let res = grpc.unary(method, req).await;
1520 Ok(res)
1521 };
1522 Box::pin(fut)
1523 }
1524 "/ddkrpc.DdkRpc/Send" => {
1525 #[allow(non_camel_case_types)]
1526 struct SendSvc<T: DdkRpc>(pub Arc<T>);
1527 impl<T: DdkRpc> tonic::server::UnaryService<super::SendRequest>
1528 for SendSvc<T> {
1529 type Response = super::SendResponse;
1530 type Future = BoxFuture<
1531 tonic::Response<Self::Response>,
1532 tonic::Status,
1533 >;
1534 fn call(
1535 &mut self,
1536 request: tonic::Request<super::SendRequest>,
1537 ) -> Self::Future {
1538 let inner = Arc::clone(&self.0);
1539 let fut = async move {
1540 <T as DdkRpc>::send(&inner, request).await
1541 };
1542 Box::pin(fut)
1543 }
1544 }
1545 let accept_compression_encodings = self.accept_compression_encodings;
1546 let send_compression_encodings = self.send_compression_encodings;
1547 let max_decoding_message_size = self.max_decoding_message_size;
1548 let max_encoding_message_size = self.max_encoding_message_size;
1549 let inner = self.inner.clone();
1550 let fut = async move {
1551 let inner = inner.0;
1552 let method = SendSvc(inner);
1553 let codec = tonic::codec::ProstCodec::default();
1554 let mut grpc = tonic::server::Grpc::new(codec)
1555 .apply_compression_config(
1556 accept_compression_encodings,
1557 send_compression_encodings,
1558 )
1559 .apply_max_message_size_config(
1560 max_decoding_message_size,
1561 max_encoding_message_size,
1562 );
1563 let res = grpc.unary(method, req).await;
1564 Ok(res)
1565 };
1566 Box::pin(fut)
1567 }
1568 "/ddkrpc.DdkRpc/OracleAnnouncements" => {
1569 #[allow(non_camel_case_types)]
1570 struct OracleAnnouncementsSvc<T: DdkRpc>(pub Arc<T>);
1571 impl<
1572 T: DdkRpc,
1573 > tonic::server::UnaryService<super::OracleAnnouncementsRequest>
1574 for OracleAnnouncementsSvc<T> {
1575 type Response = super::OracleAnnouncementsResponse;
1576 type Future = BoxFuture<
1577 tonic::Response<Self::Response>,
1578 tonic::Status,
1579 >;
1580 fn call(
1581 &mut self,
1582 request: tonic::Request<super::OracleAnnouncementsRequest>,
1583 ) -> Self::Future {
1584 let inner = Arc::clone(&self.0);
1585 let fut = async move {
1586 <T as DdkRpc>::oracle_announcements(&inner, request).await
1587 };
1588 Box::pin(fut)
1589 }
1590 }
1591 let accept_compression_encodings = self.accept_compression_encodings;
1592 let send_compression_encodings = self.send_compression_encodings;
1593 let max_decoding_message_size = self.max_decoding_message_size;
1594 let max_encoding_message_size = self.max_encoding_message_size;
1595 let inner = self.inner.clone();
1596 let fut = async move {
1597 let inner = inner.0;
1598 let method = OracleAnnouncementsSvc(inner);
1599 let codec = tonic::codec::ProstCodec::default();
1600 let mut grpc = tonic::server::Grpc::new(codec)
1601 .apply_compression_config(
1602 accept_compression_encodings,
1603 send_compression_encodings,
1604 )
1605 .apply_max_message_size_config(
1606 max_decoding_message_size,
1607 max_encoding_message_size,
1608 );
1609 let res = grpc.unary(method, req).await;
1610 Ok(res)
1611 };
1612 Box::pin(fut)
1613 }
1614 "/ddkrpc.DdkRpc/CreateEnum" => {
1615 #[allow(non_camel_case_types)]
1616 struct CreateEnumSvc<T: DdkRpc>(pub Arc<T>);
1617 impl<T: DdkRpc> tonic::server::UnaryService<super::CreateEnumRequest>
1618 for CreateEnumSvc<T> {
1619 type Response = super::CreateEnumResponse;
1620 type Future = BoxFuture<
1621 tonic::Response<Self::Response>,
1622 tonic::Status,
1623 >;
1624 fn call(
1625 &mut self,
1626 request: tonic::Request<super::CreateEnumRequest>,
1627 ) -> Self::Future {
1628 let inner = Arc::clone(&self.0);
1629 let fut = async move {
1630 <T as DdkRpc>::create_enum(&inner, request).await
1631 };
1632 Box::pin(fut)
1633 }
1634 }
1635 let accept_compression_encodings = self.accept_compression_encodings;
1636 let send_compression_encodings = self.send_compression_encodings;
1637 let max_decoding_message_size = self.max_decoding_message_size;
1638 let max_encoding_message_size = self.max_encoding_message_size;
1639 let inner = self.inner.clone();
1640 let fut = async move {
1641 let inner = inner.0;
1642 let method = CreateEnumSvc(inner);
1643 let codec = tonic::codec::ProstCodec::default();
1644 let mut grpc = tonic::server::Grpc::new(codec)
1645 .apply_compression_config(
1646 accept_compression_encodings,
1647 send_compression_encodings,
1648 )
1649 .apply_max_message_size_config(
1650 max_decoding_message_size,
1651 max_encoding_message_size,
1652 );
1653 let res = grpc.unary(method, req).await;
1654 Ok(res)
1655 };
1656 Box::pin(fut)
1657 }
1658 _ => {
1659 Box::pin(async move {
1660 Ok(
1661 http::Response::builder()
1662 .status(200)
1663 .header("grpc-status", "12")
1664 .header("content-type", "application/grpc")
1665 .body(empty_body())
1666 .unwrap(),
1667 )
1668 })
1669 }
1670 }
1671 }
1672 }
1673 impl<T: DdkRpc> Clone for DdkRpcServer<T> {
1674 fn clone(&self) -> Self {
1675 let inner = self.inner.clone();
1676 Self {
1677 inner,
1678 accept_compression_encodings: self.accept_compression_encodings,
1679 send_compression_encodings: self.send_compression_encodings,
1680 max_decoding_message_size: self.max_decoding_message_size,
1681 max_encoding_message_size: self.max_encoding_message_size,
1682 }
1683 }
1684 }
1685 impl<T: DdkRpc> Clone for _Inner<T> {
1686 fn clone(&self) -> Self {
1687 Self(Arc::clone(&self.0))
1688 }
1689 }
1690 impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
1691 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1692 write!(f, "{:?}", self.0)
1693 }
1694 }
1695 impl<T: DdkRpc> tonic::server::NamedService for DdkRpcServer<T> {
1696 const NAME: &'static str = "ddkrpc.DdkRpc";
1697 }
1698}