1#[cfg(feature = "grpc")]
4pub mod query_client {
5 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
6 use tonic::codegen::http::Uri;
7 use tonic::codegen::*;
8 #[derive(Debug, Clone)]
9 pub struct QueryClient<T> {
10 inner: tonic::client::Grpc<T>,
11 }
12 #[cfg(feature = "grpc-transport")]
13 impl QueryClient<tonic::transport::Channel> {
14 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
16 where
17 D: TryInto<tonic::transport::Endpoint>,
18 D::Error: Into<StdError>,
19 {
20 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
21 Ok(Self::new(conn))
22 }
23 }
24 impl<T> QueryClient<T>
25 where
26 T: tonic::client::GrpcService<tonic::body::BoxBody>,
27 T::Error: Into<StdError>,
28 T::ResponseBody: Body<Data = Bytes> + Send + 'static,
29 <T::ResponseBody as Body>::Error: Into<StdError> + Send,
30 {
31 pub fn new(inner: T) -> Self {
32 let inner = tonic::client::Grpc::new(inner);
33 Self { inner }
34 }
35 pub fn with_origin(inner: T, origin: Uri) -> Self {
36 let inner = tonic::client::Grpc::with_origin(inner, origin);
37 Self { inner }
38 }
39 pub fn with_interceptor<F>(
40 inner: T,
41 interceptor: F,
42 ) -> QueryClient<InterceptedService<T, F>>
43 where
44 F: tonic::service::Interceptor,
45 T::ResponseBody: Default,
46 T: tonic::codegen::Service<
47 http::Request<tonic::body::BoxBody>,
48 Response = http::Response<
49 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
50 >,
51 >,
52 <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
53 Into<StdError> + Send + Sync,
54 {
55 QueryClient::new(InterceptedService::new(inner, interceptor))
56 }
57 #[must_use]
62 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
63 self.inner = self.inner.send_compressed(encoding);
64 self
65 }
66 #[must_use]
68 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
69 self.inner = self.inner.accept_compressed(encoding);
70 self
71 }
72 #[must_use]
76 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
77 self.inner = self.inner.max_decoding_message_size(limit);
78 self
79 }
80 #[must_use]
84 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
85 self.inner = self.inner.max_encoding_message_size(limit);
86 self
87 }
88 pub async fn query_params(
89 &mut self,
90 request: impl tonic::IntoRequest<super::QueryParamsRequest>,
91 ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>
92 {
93 self.inner.ready().await.map_err(|e| {
94 tonic::Status::new(
95 tonic::Code::Unknown,
96 alloc::format!("Service was not ready: {}", e.into()),
97 )
98 })?;
99 let codec = tonic::codec::ProstCodec::default();
100 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryParams");
101 let mut req = request.into_request();
102 req.extensions_mut()
103 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryParams"));
104 self.inner.unary(req, path, codec).await
105 }
106 pub async fn query_chain_tip(
107 &mut self,
108 request: impl tonic::IntoRequest<super::QueryChainTipRequest>,
109 ) -> core::result::Result<tonic::Response<super::QueryChainTipResponse>, tonic::Status>
110 {
111 self.inner.ready().await.map_err(|e| {
112 tonic::Status::new(
113 tonic::Code::Unknown,
114 alloc::format!("Service was not ready: {}", e.into()),
115 )
116 })?;
117 let codec = tonic::codec::ProstCodec::default();
118 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryChainTip");
119 let mut req = request.into_request();
120 req.extensions_mut()
121 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryChainTip"));
122 self.inner.unary(req, path, codec).await
123 }
124 pub async fn query_block_header_by_height(
125 &mut self,
126 request: impl tonic::IntoRequest<super::QueryBlockHeaderByHeightRequest>,
127 ) -> core::result::Result<
128 tonic::Response<super::QueryBlockHeaderByHeightResponse>,
129 tonic::Status,
130 > {
131 self.inner.ready().await.map_err(|e| {
132 tonic::Status::new(
133 tonic::Code::Unknown,
134 alloc::format!("Service was not ready: {}", e.into()),
135 )
136 })?;
137 let codec = tonic::codec::ProstCodec::default();
138 let path = http::uri::PathAndQuery::from_static(
139 "/side.btcbridge.Query/QueryBlockHeaderByHeight",
140 );
141 let mut req = request.into_request();
142 req.extensions_mut().insert(GrpcMethod::new(
143 "side.btcbridge.Query",
144 "QueryBlockHeaderByHeight",
145 ));
146 self.inner.unary(req, path, codec).await
147 }
148 pub async fn query_block_header_by_hash(
149 &mut self,
150 request: impl tonic::IntoRequest<super::QueryBlockHeaderByHashRequest>,
151 ) -> core::result::Result<
152 tonic::Response<super::QueryBlockHeaderByHashResponse>,
153 tonic::Status,
154 > {
155 self.inner.ready().await.map_err(|e| {
156 tonic::Status::new(
157 tonic::Code::Unknown,
158 alloc::format!("Service was not ready: {}", e.into()),
159 )
160 })?;
161 let codec = tonic::codec::ProstCodec::default();
162 let path = http::uri::PathAndQuery::from_static(
163 "/side.btcbridge.Query/QueryBlockHeaderByHash",
164 );
165 let mut req = request.into_request();
166 req.extensions_mut().insert(GrpcMethod::new(
167 "side.btcbridge.Query",
168 "QueryBlockHeaderByHash",
169 ));
170 self.inner.unary(req, path, codec).await
171 }
172 pub async fn query_fee_rate(
173 &mut self,
174 request: impl tonic::IntoRequest<super::QueryFeeRateRequest>,
175 ) -> core::result::Result<tonic::Response<super::QueryFeeRateResponse>, tonic::Status>
176 {
177 self.inner.ready().await.map_err(|e| {
178 tonic::Status::new(
179 tonic::Code::Unknown,
180 alloc::format!("Service was not ready: {}", e.into()),
181 )
182 })?;
183 let codec = tonic::codec::ProstCodec::default();
184 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryFeeRate");
185 let mut req = request.into_request();
186 req.extensions_mut()
187 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryFeeRate"));
188 self.inner.unary(req, path, codec).await
189 }
190 pub async fn query_withdrawal_network_fee(
191 &mut self,
192 request: impl tonic::IntoRequest<super::QueryWithdrawalNetworkFeeRequest>,
193 ) -> core::result::Result<
194 tonic::Response<super::QueryWithdrawalNetworkFeeResponse>,
195 tonic::Status,
196 > {
197 self.inner.ready().await.map_err(|e| {
198 tonic::Status::new(
199 tonic::Code::Unknown,
200 alloc::format!("Service was not ready: {}", e.into()),
201 )
202 })?;
203 let codec = tonic::codec::ProstCodec::default();
204 let path = http::uri::PathAndQuery::from_static(
205 "/side.btcbridge.Query/QueryWithdrawalNetworkFee",
206 );
207 let mut req = request.into_request();
208 req.extensions_mut().insert(GrpcMethod::new(
209 "side.btcbridge.Query",
210 "QueryWithdrawalNetworkFee",
211 ));
212 self.inner.unary(req, path, codec).await
213 }
214 pub async fn query_withdraw_requests_by_address(
215 &mut self,
216 request: impl tonic::IntoRequest<super::QueryWithdrawRequestsByAddressRequest>,
217 ) -> core::result::Result<
218 tonic::Response<super::QueryWithdrawRequestsByAddressResponse>,
219 tonic::Status,
220 > {
221 self.inner.ready().await.map_err(|e| {
222 tonic::Status::new(
223 tonic::Code::Unknown,
224 alloc::format!("Service was not ready: {}", e.into()),
225 )
226 })?;
227 let codec = tonic::codec::ProstCodec::default();
228 let path = http::uri::PathAndQuery::from_static(
229 "/side.btcbridge.Query/QueryWithdrawRequestsByAddress",
230 );
231 let mut req = request.into_request();
232 req.extensions_mut().insert(GrpcMethod::new(
233 "side.btcbridge.Query",
234 "QueryWithdrawRequestsByAddress",
235 ));
236 self.inner.unary(req, path, codec).await
237 }
238 pub async fn query_withdraw_requests_by_tx_hash(
239 &mut self,
240 request: impl tonic::IntoRequest<super::QueryWithdrawRequestsByTxHashRequest>,
241 ) -> core::result::Result<
242 tonic::Response<super::QueryWithdrawRequestsByTxHashResponse>,
243 tonic::Status,
244 > {
245 self.inner.ready().await.map_err(|e| {
246 tonic::Status::new(
247 tonic::Code::Unknown,
248 alloc::format!("Service was not ready: {}", e.into()),
249 )
250 })?;
251 let codec = tonic::codec::ProstCodec::default();
252 let path = http::uri::PathAndQuery::from_static(
253 "/side.btcbridge.Query/QueryWithdrawRequestsByTxHash",
254 );
255 let mut req = request.into_request();
256 req.extensions_mut().insert(GrpcMethod::new(
257 "side.btcbridge.Query",
258 "QueryWithdrawRequestsByTxHash",
259 ));
260 self.inner.unary(req, path, codec).await
261 }
262 pub async fn query_pending_btc_withdraw_requests(
263 &mut self,
264 request: impl tonic::IntoRequest<super::QueryPendingBtcWithdrawRequestsRequest>,
265 ) -> core::result::Result<
266 tonic::Response<super::QueryPendingBtcWithdrawRequestsResponse>,
267 tonic::Status,
268 > {
269 self.inner.ready().await.map_err(|e| {
270 tonic::Status::new(
271 tonic::Code::Unknown,
272 alloc::format!("Service was not ready: {}", e.into()),
273 )
274 })?;
275 let codec = tonic::codec::ProstCodec::default();
276 let path = http::uri::PathAndQuery::from_static(
277 "/side.btcbridge.Query/QueryPendingBtcWithdrawRequests",
278 );
279 let mut req = request.into_request();
280 req.extensions_mut().insert(GrpcMethod::new(
281 "side.btcbridge.Query",
282 "QueryPendingBtcWithdrawRequests",
283 ));
284 self.inner.unary(req, path, codec).await
285 }
286 pub async fn query_signing_requests(
287 &mut self,
288 request: impl tonic::IntoRequest<super::QuerySigningRequestsRequest>,
289 ) -> core::result::Result<tonic::Response<super::QuerySigningRequestsResponse>, tonic::Status>
290 {
291 self.inner.ready().await.map_err(|e| {
292 tonic::Status::new(
293 tonic::Code::Unknown,
294 alloc::format!("Service was not ready: {}", e.into()),
295 )
296 })?;
297 let codec = tonic::codec::ProstCodec::default();
298 let path =
299 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QuerySigningRequests");
300 let mut req = request.into_request();
301 req.extensions_mut().insert(GrpcMethod::new(
302 "side.btcbridge.Query",
303 "QuerySigningRequests",
304 ));
305 self.inner.unary(req, path, codec).await
306 }
307 pub async fn query_signing_requests_by_address(
308 &mut self,
309 request: impl tonic::IntoRequest<super::QuerySigningRequestsByAddressRequest>,
310 ) -> core::result::Result<
311 tonic::Response<super::QuerySigningRequestsByAddressResponse>,
312 tonic::Status,
313 > {
314 self.inner.ready().await.map_err(|e| {
315 tonic::Status::new(
316 tonic::Code::Unknown,
317 alloc::format!("Service was not ready: {}", e.into()),
318 )
319 })?;
320 let codec = tonic::codec::ProstCodec::default();
321 let path = http::uri::PathAndQuery::from_static(
322 "/side.btcbridge.Query/QuerySigningRequestsByAddress",
323 );
324 let mut req = request.into_request();
325 req.extensions_mut().insert(GrpcMethod::new(
326 "side.btcbridge.Query",
327 "QuerySigningRequestsByAddress",
328 ));
329 self.inner.unary(req, path, codec).await
330 }
331 pub async fn query_signing_request_by_tx_hash(
332 &mut self,
333 request: impl tonic::IntoRequest<super::QuerySigningRequestByTxHashRequest>,
334 ) -> core::result::Result<
335 tonic::Response<super::QuerySigningRequestByTxHashResponse>,
336 tonic::Status,
337 > {
338 self.inner.ready().await.map_err(|e| {
339 tonic::Status::new(
340 tonic::Code::Unknown,
341 alloc::format!("Service was not ready: {}", e.into()),
342 )
343 })?;
344 let codec = tonic::codec::ProstCodec::default();
345 let path = http::uri::PathAndQuery::from_static(
346 "/side.btcbridge.Query/QuerySigningRequestByTxHash",
347 );
348 let mut req = request.into_request();
349 req.extensions_mut().insert(GrpcMethod::new(
350 "side.btcbridge.Query",
351 "QuerySigningRequestByTxHash",
352 ));
353 self.inner.unary(req, path, codec).await
354 }
355 pub async fn query_utx_os(
356 &mut self,
357 request: impl tonic::IntoRequest<super::QueryUtxOsRequest>,
358 ) -> core::result::Result<tonic::Response<super::QueryUtxOsResponse>, tonic::Status>
359 {
360 self.inner.ready().await.map_err(|e| {
361 tonic::Status::new(
362 tonic::Code::Unknown,
363 alloc::format!("Service was not ready: {}", e.into()),
364 )
365 })?;
366 let codec = tonic::codec::ProstCodec::default();
367 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryUTXOs");
368 let mut req = request.into_request();
369 req.extensions_mut()
370 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryUTXOs"));
371 self.inner.unary(req, path, codec).await
372 }
373 pub async fn query_utx_os_by_address(
374 &mut self,
375 request: impl tonic::IntoRequest<super::QueryUtxOsByAddressRequest>,
376 ) -> core::result::Result<tonic::Response<super::QueryUtxOsByAddressResponse>, tonic::Status>
377 {
378 self.inner.ready().await.map_err(|e| {
379 tonic::Status::new(
380 tonic::Code::Unknown,
381 alloc::format!("Service was not ready: {}", e.into()),
382 )
383 })?;
384 let codec = tonic::codec::ProstCodec::default();
385 let path =
386 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryUTXOsByAddress");
387 let mut req = request.into_request();
388 req.extensions_mut().insert(GrpcMethod::new(
389 "side.btcbridge.Query",
390 "QueryUTXOsByAddress",
391 ));
392 self.inner.unary(req, path, codec).await
393 }
394 pub async fn query_utxo_count_and_balances_by_address(
395 &mut self,
396 request: impl tonic::IntoRequest<super::QueryUtxoCountAndBalancesByAddressRequest>,
397 ) -> core::result::Result<
398 tonic::Response<super::QueryUtxoCountAndBalancesByAddressResponse>,
399 tonic::Status,
400 > {
401 self.inner.ready().await.map_err(|e| {
402 tonic::Status::new(
403 tonic::Code::Unknown,
404 alloc::format!("Service was not ready: {}", e.into()),
405 )
406 })?;
407 let codec = tonic::codec::ProstCodec::default();
408 let path = http::uri::PathAndQuery::from_static(
409 "/side.btcbridge.Query/QueryUTXOCountAndBalancesByAddress",
410 );
411 let mut req = request.into_request();
412 req.extensions_mut().insert(GrpcMethod::new(
413 "side.btcbridge.Query",
414 "QueryUTXOCountAndBalancesByAddress",
415 ));
416 self.inner.unary(req, path, codec).await
417 }
418 pub async fn query_dkg_request(
419 &mut self,
420 request: impl tonic::IntoRequest<super::QueryDkgRequestRequest>,
421 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestResponse>, tonic::Status>
422 {
423 self.inner.ready().await.map_err(|e| {
424 tonic::Status::new(
425 tonic::Code::Unknown,
426 alloc::format!("Service was not ready: {}", e.into()),
427 )
428 })?;
429 let codec = tonic::codec::ProstCodec::default();
430 let path =
431 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryDKGRequest");
432 let mut req = request.into_request();
433 req.extensions_mut()
434 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryDKGRequest"));
435 self.inner.unary(req, path, codec).await
436 }
437 pub async fn query_dkg_requests(
438 &mut self,
439 request: impl tonic::IntoRequest<super::QueryDkgRequestsRequest>,
440 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestsResponse>, tonic::Status>
441 {
442 self.inner.ready().await.map_err(|e| {
443 tonic::Status::new(
444 tonic::Code::Unknown,
445 alloc::format!("Service was not ready: {}", e.into()),
446 )
447 })?;
448 let codec = tonic::codec::ProstCodec::default();
449 let path =
450 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryDKGRequests");
451 let mut req = request.into_request();
452 req.extensions_mut()
453 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryDKGRequests"));
454 self.inner.unary(req, path, codec).await
455 }
456 pub async fn query_all_dkg_requests(
457 &mut self,
458 request: impl tonic::IntoRequest<super::QueryAllDkgRequestsRequest>,
459 ) -> core::result::Result<tonic::Response<super::QueryAllDkgRequestsResponse>, tonic::Status>
460 {
461 self.inner.ready().await.map_err(|e| {
462 tonic::Status::new(
463 tonic::Code::Unknown,
464 alloc::format!("Service was not ready: {}", e.into()),
465 )
466 })?;
467 let codec = tonic::codec::ProstCodec::default();
468 let path =
469 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryAllDKGRequests");
470 let mut req = request.into_request();
471 req.extensions_mut().insert(GrpcMethod::new(
472 "side.btcbridge.Query",
473 "QueryAllDKGRequests",
474 ));
475 self.inner.unary(req, path, codec).await
476 }
477 pub async fn query_dkg_completion_requests(
478 &mut self,
479 request: impl tonic::IntoRequest<super::QueryDkgCompletionRequestsRequest>,
480 ) -> core::result::Result<
481 tonic::Response<super::QueryDkgCompletionRequestsResponse>,
482 tonic::Status,
483 > {
484 self.inner.ready().await.map_err(|e| {
485 tonic::Status::new(
486 tonic::Code::Unknown,
487 alloc::format!("Service was not ready: {}", e.into()),
488 )
489 })?;
490 let codec = tonic::codec::ProstCodec::default();
491 let path = http::uri::PathAndQuery::from_static(
492 "/side.btcbridge.Query/QueryDKGCompletionRequests",
493 );
494 let mut req = request.into_request();
495 req.extensions_mut().insert(GrpcMethod::new(
496 "side.btcbridge.Query",
497 "QueryDKGCompletionRequests",
498 ));
499 self.inner.unary(req, path, codec).await
500 }
501 }
502}
503#[cfg(feature = "grpc")]
505pub mod query_server {
506 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
507 use tonic::codegen::*;
508 #[async_trait]
510 pub trait Query: Send + Sync + 'static {
511 async fn query_params(
512 &self,
513 request: tonic::Request<super::QueryParamsRequest>,
514 ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
515 async fn query_chain_tip(
516 &self,
517 request: tonic::Request<super::QueryChainTipRequest>,
518 ) -> core::result::Result<tonic::Response<super::QueryChainTipResponse>, tonic::Status>;
519 async fn query_block_header_by_height(
520 &self,
521 request: tonic::Request<super::QueryBlockHeaderByHeightRequest>,
522 ) -> core::result::Result<
523 tonic::Response<super::QueryBlockHeaderByHeightResponse>,
524 tonic::Status,
525 >;
526 async fn query_block_header_by_hash(
527 &self,
528 request: tonic::Request<super::QueryBlockHeaderByHashRequest>,
529 ) -> core::result::Result<
530 tonic::Response<super::QueryBlockHeaderByHashResponse>,
531 tonic::Status,
532 >;
533 async fn query_fee_rate(
534 &self,
535 request: tonic::Request<super::QueryFeeRateRequest>,
536 ) -> core::result::Result<tonic::Response<super::QueryFeeRateResponse>, tonic::Status>;
537 async fn query_withdrawal_network_fee(
538 &self,
539 request: tonic::Request<super::QueryWithdrawalNetworkFeeRequest>,
540 ) -> core::result::Result<
541 tonic::Response<super::QueryWithdrawalNetworkFeeResponse>,
542 tonic::Status,
543 >;
544 async fn query_withdraw_requests_by_address(
545 &self,
546 request: tonic::Request<super::QueryWithdrawRequestsByAddressRequest>,
547 ) -> core::result::Result<
548 tonic::Response<super::QueryWithdrawRequestsByAddressResponse>,
549 tonic::Status,
550 >;
551 async fn query_withdraw_requests_by_tx_hash(
552 &self,
553 request: tonic::Request<super::QueryWithdrawRequestsByTxHashRequest>,
554 ) -> core::result::Result<
555 tonic::Response<super::QueryWithdrawRequestsByTxHashResponse>,
556 tonic::Status,
557 >;
558 async fn query_pending_btc_withdraw_requests(
559 &self,
560 request: tonic::Request<super::QueryPendingBtcWithdrawRequestsRequest>,
561 ) -> core::result::Result<
562 tonic::Response<super::QueryPendingBtcWithdrawRequestsResponse>,
563 tonic::Status,
564 >;
565 async fn query_signing_requests(
566 &self,
567 request: tonic::Request<super::QuerySigningRequestsRequest>,
568 ) -> core::result::Result<tonic::Response<super::QuerySigningRequestsResponse>, tonic::Status>;
569 async fn query_signing_requests_by_address(
570 &self,
571 request: tonic::Request<super::QuerySigningRequestsByAddressRequest>,
572 ) -> core::result::Result<
573 tonic::Response<super::QuerySigningRequestsByAddressResponse>,
574 tonic::Status,
575 >;
576 async fn query_signing_request_by_tx_hash(
577 &self,
578 request: tonic::Request<super::QuerySigningRequestByTxHashRequest>,
579 ) -> core::result::Result<
580 tonic::Response<super::QuerySigningRequestByTxHashResponse>,
581 tonic::Status,
582 >;
583 async fn query_utx_os(
584 &self,
585 request: tonic::Request<super::QueryUtxOsRequest>,
586 ) -> core::result::Result<tonic::Response<super::QueryUtxOsResponse>, tonic::Status>;
587 async fn query_utx_os_by_address(
588 &self,
589 request: tonic::Request<super::QueryUtxOsByAddressRequest>,
590 ) -> core::result::Result<tonic::Response<super::QueryUtxOsByAddressResponse>, tonic::Status>;
591 async fn query_utxo_count_and_balances_by_address(
592 &self,
593 request: tonic::Request<super::QueryUtxoCountAndBalancesByAddressRequest>,
594 ) -> core::result::Result<
595 tonic::Response<super::QueryUtxoCountAndBalancesByAddressResponse>,
596 tonic::Status,
597 >;
598 async fn query_dkg_request(
599 &self,
600 request: tonic::Request<super::QueryDkgRequestRequest>,
601 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestResponse>, tonic::Status>;
602 async fn query_dkg_requests(
603 &self,
604 request: tonic::Request<super::QueryDkgRequestsRequest>,
605 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestsResponse>, tonic::Status>;
606 async fn query_all_dkg_requests(
607 &self,
608 request: tonic::Request<super::QueryAllDkgRequestsRequest>,
609 ) -> core::result::Result<tonic::Response<super::QueryAllDkgRequestsResponse>, tonic::Status>;
610 async fn query_dkg_completion_requests(
611 &self,
612 request: tonic::Request<super::QueryDkgCompletionRequestsRequest>,
613 ) -> core::result::Result<
614 tonic::Response<super::QueryDkgCompletionRequestsResponse>,
615 tonic::Status,
616 >;
617 }
618 #[derive(Debug)]
619 pub struct QueryServer<T: Query> {
620 inner: _Inner<T>,
621 accept_compression_encodings: EnabledCompressionEncodings,
622 send_compression_encodings: EnabledCompressionEncodings,
623 max_decoding_message_size: Option<usize>,
624 max_encoding_message_size: Option<usize>,
625 }
626 struct _Inner<T>(Arc<T>);
627 impl<T: Query> QueryServer<T> {
628 pub fn new(inner: T) -> Self {
629 Self::from_arc(Arc::new(inner))
630 }
631 pub fn from_arc(inner: Arc<T>) -> Self {
632 let inner = _Inner(inner);
633 Self {
634 inner,
635 accept_compression_encodings: Default::default(),
636 send_compression_encodings: Default::default(),
637 max_decoding_message_size: None,
638 max_encoding_message_size: None,
639 }
640 }
641 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
642 where
643 F: tonic::service::Interceptor,
644 {
645 InterceptedService::new(Self::new(inner), interceptor)
646 }
647 #[must_use]
649 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
650 self.accept_compression_encodings.enable(encoding);
651 self
652 }
653 #[must_use]
655 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
656 self.send_compression_encodings.enable(encoding);
657 self
658 }
659 #[must_use]
663 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
664 self.max_decoding_message_size = Some(limit);
665 self
666 }
667 #[must_use]
671 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
672 self.max_encoding_message_size = Some(limit);
673 self
674 }
675 }
676 impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
677 where
678 T: Query,
679 B: Body + Send + 'static,
680 B::Error: Into<StdError> + Send + 'static,
681 {
682 type Response = http::Response<tonic::body::BoxBody>;
683 type Error = std::convert::Infallible;
684 type Future = BoxFuture<Self::Response, Self::Error>;
685 fn poll_ready(
686 &mut self,
687 _cx: &mut Context<'_>,
688 ) -> Poll<core::result::Result<(), Self::Error>> {
689 Poll::Ready(Ok(()))
690 }
691 fn call(&mut self, req: http::Request<B>) -> Self::Future {
692 let inner = self.inner.clone();
693 match req.uri().path() {
694 "/side.btcbridge.Query/QueryParams" => {
695 #[allow(non_camel_case_types)]
696 struct QueryParamsSvc<T: Query>(pub Arc<T>);
697 impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for QueryParamsSvc<T> {
698 type Response = super::QueryParamsResponse;
699 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
700 fn call(
701 &mut self,
702 request: tonic::Request<super::QueryParamsRequest>,
703 ) -> Self::Future {
704 let inner = Arc::clone(&self.0);
705 let fut = async move { (*inner).query_params(request).await };
706 Box::pin(fut)
707 }
708 }
709 let accept_compression_encodings = self.accept_compression_encodings;
710 let send_compression_encodings = self.send_compression_encodings;
711 let max_decoding_message_size = self.max_decoding_message_size;
712 let max_encoding_message_size = self.max_encoding_message_size;
713 let inner = self.inner.clone();
714 let fut = async move {
715 let inner = inner.0;
716 let method = QueryParamsSvc(inner);
717 let codec = tonic::codec::ProstCodec::default();
718 let mut grpc = tonic::server::Grpc::new(codec)
719 .apply_compression_config(
720 accept_compression_encodings,
721 send_compression_encodings,
722 )
723 .apply_max_message_size_config(
724 max_decoding_message_size,
725 max_encoding_message_size,
726 );
727 let res = grpc.unary(method, req).await;
728 Ok(res)
729 };
730 Box::pin(fut)
731 }
732 "/side.btcbridge.Query/QueryChainTip" => {
733 #[allow(non_camel_case_types)]
734 struct QueryChainTipSvc<T: Query>(pub Arc<T>);
735 impl<T: Query> tonic::server::UnaryService<super::QueryChainTipRequest> for QueryChainTipSvc<T> {
736 type Response = super::QueryChainTipResponse;
737 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
738 fn call(
739 &mut self,
740 request: tonic::Request<super::QueryChainTipRequest>,
741 ) -> Self::Future {
742 let inner = Arc::clone(&self.0);
743 let fut = async move { (*inner).query_chain_tip(request).await };
744 Box::pin(fut)
745 }
746 }
747 let accept_compression_encodings = self.accept_compression_encodings;
748 let send_compression_encodings = self.send_compression_encodings;
749 let max_decoding_message_size = self.max_decoding_message_size;
750 let max_encoding_message_size = self.max_encoding_message_size;
751 let inner = self.inner.clone();
752 let fut = async move {
753 let inner = inner.0;
754 let method = QueryChainTipSvc(inner);
755 let codec = tonic::codec::ProstCodec::default();
756 let mut grpc = tonic::server::Grpc::new(codec)
757 .apply_compression_config(
758 accept_compression_encodings,
759 send_compression_encodings,
760 )
761 .apply_max_message_size_config(
762 max_decoding_message_size,
763 max_encoding_message_size,
764 );
765 let res = grpc.unary(method, req).await;
766 Ok(res)
767 };
768 Box::pin(fut)
769 }
770 "/side.btcbridge.Query/QueryBlockHeaderByHeight" => {
771 #[allow(non_camel_case_types)]
772 struct QueryBlockHeaderByHeightSvc<T: Query>(pub Arc<T>);
773 impl<T: Query>
774 tonic::server::UnaryService<super::QueryBlockHeaderByHeightRequest>
775 for QueryBlockHeaderByHeightSvc<T>
776 {
777 type Response = super::QueryBlockHeaderByHeightResponse;
778 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
779 fn call(
780 &mut self,
781 request: tonic::Request<super::QueryBlockHeaderByHeightRequest>,
782 ) -> Self::Future {
783 let inner = Arc::clone(&self.0);
784 let fut =
785 async move { (*inner).query_block_header_by_height(request).await };
786 Box::pin(fut)
787 }
788 }
789 let accept_compression_encodings = self.accept_compression_encodings;
790 let send_compression_encodings = self.send_compression_encodings;
791 let max_decoding_message_size = self.max_decoding_message_size;
792 let max_encoding_message_size = self.max_encoding_message_size;
793 let inner = self.inner.clone();
794 let fut = async move {
795 let inner = inner.0;
796 let method = QueryBlockHeaderByHeightSvc(inner);
797 let codec = tonic::codec::ProstCodec::default();
798 let mut grpc = tonic::server::Grpc::new(codec)
799 .apply_compression_config(
800 accept_compression_encodings,
801 send_compression_encodings,
802 )
803 .apply_max_message_size_config(
804 max_decoding_message_size,
805 max_encoding_message_size,
806 );
807 let res = grpc.unary(method, req).await;
808 Ok(res)
809 };
810 Box::pin(fut)
811 }
812 "/side.btcbridge.Query/QueryBlockHeaderByHash" => {
813 #[allow(non_camel_case_types)]
814 struct QueryBlockHeaderByHashSvc<T: Query>(pub Arc<T>);
815 impl<T: Query> tonic::server::UnaryService<super::QueryBlockHeaderByHashRequest>
816 for QueryBlockHeaderByHashSvc<T>
817 {
818 type Response = super::QueryBlockHeaderByHashResponse;
819 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
820 fn call(
821 &mut self,
822 request: tonic::Request<super::QueryBlockHeaderByHashRequest>,
823 ) -> Self::Future {
824 let inner = Arc::clone(&self.0);
825 let fut =
826 async move { (*inner).query_block_header_by_hash(request).await };
827 Box::pin(fut)
828 }
829 }
830 let accept_compression_encodings = self.accept_compression_encodings;
831 let send_compression_encodings = self.send_compression_encodings;
832 let max_decoding_message_size = self.max_decoding_message_size;
833 let max_encoding_message_size = self.max_encoding_message_size;
834 let inner = self.inner.clone();
835 let fut = async move {
836 let inner = inner.0;
837 let method = QueryBlockHeaderByHashSvc(inner);
838 let codec = tonic::codec::ProstCodec::default();
839 let mut grpc = tonic::server::Grpc::new(codec)
840 .apply_compression_config(
841 accept_compression_encodings,
842 send_compression_encodings,
843 )
844 .apply_max_message_size_config(
845 max_decoding_message_size,
846 max_encoding_message_size,
847 );
848 let res = grpc.unary(method, req).await;
849 Ok(res)
850 };
851 Box::pin(fut)
852 }
853 "/side.btcbridge.Query/QueryFeeRate" => {
854 #[allow(non_camel_case_types)]
855 struct QueryFeeRateSvc<T: Query>(pub Arc<T>);
856 impl<T: Query> tonic::server::UnaryService<super::QueryFeeRateRequest> for QueryFeeRateSvc<T> {
857 type Response = super::QueryFeeRateResponse;
858 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
859 fn call(
860 &mut self,
861 request: tonic::Request<super::QueryFeeRateRequest>,
862 ) -> Self::Future {
863 let inner = Arc::clone(&self.0);
864 let fut = async move { (*inner).query_fee_rate(request).await };
865 Box::pin(fut)
866 }
867 }
868 let accept_compression_encodings = self.accept_compression_encodings;
869 let send_compression_encodings = self.send_compression_encodings;
870 let max_decoding_message_size = self.max_decoding_message_size;
871 let max_encoding_message_size = self.max_encoding_message_size;
872 let inner = self.inner.clone();
873 let fut = async move {
874 let inner = inner.0;
875 let method = QueryFeeRateSvc(inner);
876 let codec = tonic::codec::ProstCodec::default();
877 let mut grpc = tonic::server::Grpc::new(codec)
878 .apply_compression_config(
879 accept_compression_encodings,
880 send_compression_encodings,
881 )
882 .apply_max_message_size_config(
883 max_decoding_message_size,
884 max_encoding_message_size,
885 );
886 let res = grpc.unary(method, req).await;
887 Ok(res)
888 };
889 Box::pin(fut)
890 }
891 "/side.btcbridge.Query/QueryWithdrawalNetworkFee" => {
892 #[allow(non_camel_case_types)]
893 struct QueryWithdrawalNetworkFeeSvc<T: Query>(pub Arc<T>);
894 impl<T: Query>
895 tonic::server::UnaryService<super::QueryWithdrawalNetworkFeeRequest>
896 for QueryWithdrawalNetworkFeeSvc<T>
897 {
898 type Response = super::QueryWithdrawalNetworkFeeResponse;
899 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
900 fn call(
901 &mut self,
902 request: tonic::Request<super::QueryWithdrawalNetworkFeeRequest>,
903 ) -> Self::Future {
904 let inner = Arc::clone(&self.0);
905 let fut =
906 async move { (*inner).query_withdrawal_network_fee(request).await };
907 Box::pin(fut)
908 }
909 }
910 let accept_compression_encodings = self.accept_compression_encodings;
911 let send_compression_encodings = self.send_compression_encodings;
912 let max_decoding_message_size = self.max_decoding_message_size;
913 let max_encoding_message_size = self.max_encoding_message_size;
914 let inner = self.inner.clone();
915 let fut = async move {
916 let inner = inner.0;
917 let method = QueryWithdrawalNetworkFeeSvc(inner);
918 let codec = tonic::codec::ProstCodec::default();
919 let mut grpc = tonic::server::Grpc::new(codec)
920 .apply_compression_config(
921 accept_compression_encodings,
922 send_compression_encodings,
923 )
924 .apply_max_message_size_config(
925 max_decoding_message_size,
926 max_encoding_message_size,
927 );
928 let res = grpc.unary(method, req).await;
929 Ok(res)
930 };
931 Box::pin(fut)
932 }
933 "/side.btcbridge.Query/QueryWithdrawRequestsByAddress" => {
934 #[allow(non_camel_case_types)]
935 struct QueryWithdrawRequestsByAddressSvc<T: Query>(pub Arc<T>);
936 impl<T: Query>
937 tonic::server::UnaryService<super::QueryWithdrawRequestsByAddressRequest>
938 for QueryWithdrawRequestsByAddressSvc<T>
939 {
940 type Response = super::QueryWithdrawRequestsByAddressResponse;
941 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
942 fn call(
943 &mut self,
944 request: tonic::Request<super::QueryWithdrawRequestsByAddressRequest>,
945 ) -> Self::Future {
946 let inner = Arc::clone(&self.0);
947 let fut = async move {
948 (*inner).query_withdraw_requests_by_address(request).await
949 };
950 Box::pin(fut)
951 }
952 }
953 let accept_compression_encodings = self.accept_compression_encodings;
954 let send_compression_encodings = self.send_compression_encodings;
955 let max_decoding_message_size = self.max_decoding_message_size;
956 let max_encoding_message_size = self.max_encoding_message_size;
957 let inner = self.inner.clone();
958 let fut = async move {
959 let inner = inner.0;
960 let method = QueryWithdrawRequestsByAddressSvc(inner);
961 let codec = tonic::codec::ProstCodec::default();
962 let mut grpc = tonic::server::Grpc::new(codec)
963 .apply_compression_config(
964 accept_compression_encodings,
965 send_compression_encodings,
966 )
967 .apply_max_message_size_config(
968 max_decoding_message_size,
969 max_encoding_message_size,
970 );
971 let res = grpc.unary(method, req).await;
972 Ok(res)
973 };
974 Box::pin(fut)
975 }
976 "/side.btcbridge.Query/QueryWithdrawRequestsByTxHash" => {
977 #[allow(non_camel_case_types)]
978 struct QueryWithdrawRequestsByTxHashSvc<T: Query>(pub Arc<T>);
979 impl<T: Query>
980 tonic::server::UnaryService<super::QueryWithdrawRequestsByTxHashRequest>
981 for QueryWithdrawRequestsByTxHashSvc<T>
982 {
983 type Response = super::QueryWithdrawRequestsByTxHashResponse;
984 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
985 fn call(
986 &mut self,
987 request: tonic::Request<super::QueryWithdrawRequestsByTxHashRequest>,
988 ) -> Self::Future {
989 let inner = Arc::clone(&self.0);
990 let fut = async move {
991 (*inner).query_withdraw_requests_by_tx_hash(request).await
992 };
993 Box::pin(fut)
994 }
995 }
996 let accept_compression_encodings = self.accept_compression_encodings;
997 let send_compression_encodings = self.send_compression_encodings;
998 let max_decoding_message_size = self.max_decoding_message_size;
999 let max_encoding_message_size = self.max_encoding_message_size;
1000 let inner = self.inner.clone();
1001 let fut = async move {
1002 let inner = inner.0;
1003 let method = QueryWithdrawRequestsByTxHashSvc(inner);
1004 let codec = tonic::codec::ProstCodec::default();
1005 let mut grpc = tonic::server::Grpc::new(codec)
1006 .apply_compression_config(
1007 accept_compression_encodings,
1008 send_compression_encodings,
1009 )
1010 .apply_max_message_size_config(
1011 max_decoding_message_size,
1012 max_encoding_message_size,
1013 );
1014 let res = grpc.unary(method, req).await;
1015 Ok(res)
1016 };
1017 Box::pin(fut)
1018 }
1019 "/side.btcbridge.Query/QueryPendingBtcWithdrawRequests" => {
1020 #[allow(non_camel_case_types)]
1021 struct QueryPendingBtcWithdrawRequestsSvc<T: Query>(pub Arc<T>);
1022 impl<T: Query>
1023 tonic::server::UnaryService<super::QueryPendingBtcWithdrawRequestsRequest>
1024 for QueryPendingBtcWithdrawRequestsSvc<T>
1025 {
1026 type Response = super::QueryPendingBtcWithdrawRequestsResponse;
1027 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1028 fn call(
1029 &mut self,
1030 request: tonic::Request<super::QueryPendingBtcWithdrawRequestsRequest>,
1031 ) -> Self::Future {
1032 let inner = Arc::clone(&self.0);
1033 let fut = async move {
1034 (*inner).query_pending_btc_withdraw_requests(request).await
1035 };
1036 Box::pin(fut)
1037 }
1038 }
1039 let accept_compression_encodings = self.accept_compression_encodings;
1040 let send_compression_encodings = self.send_compression_encodings;
1041 let max_decoding_message_size = self.max_decoding_message_size;
1042 let max_encoding_message_size = self.max_encoding_message_size;
1043 let inner = self.inner.clone();
1044 let fut = async move {
1045 let inner = inner.0;
1046 let method = QueryPendingBtcWithdrawRequestsSvc(inner);
1047 let codec = tonic::codec::ProstCodec::default();
1048 let mut grpc = tonic::server::Grpc::new(codec)
1049 .apply_compression_config(
1050 accept_compression_encodings,
1051 send_compression_encodings,
1052 )
1053 .apply_max_message_size_config(
1054 max_decoding_message_size,
1055 max_encoding_message_size,
1056 );
1057 let res = grpc.unary(method, req).await;
1058 Ok(res)
1059 };
1060 Box::pin(fut)
1061 }
1062 "/side.btcbridge.Query/QuerySigningRequests" => {
1063 #[allow(non_camel_case_types)]
1064 struct QuerySigningRequestsSvc<T: Query>(pub Arc<T>);
1065 impl<T: Query> tonic::server::UnaryService<super::QuerySigningRequestsRequest>
1066 for QuerySigningRequestsSvc<T>
1067 {
1068 type Response = super::QuerySigningRequestsResponse;
1069 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1070 fn call(
1071 &mut self,
1072 request: tonic::Request<super::QuerySigningRequestsRequest>,
1073 ) -> Self::Future {
1074 let inner = Arc::clone(&self.0);
1075 let fut = async move { (*inner).query_signing_requests(request).await };
1076 Box::pin(fut)
1077 }
1078 }
1079 let accept_compression_encodings = self.accept_compression_encodings;
1080 let send_compression_encodings = self.send_compression_encodings;
1081 let max_decoding_message_size = self.max_decoding_message_size;
1082 let max_encoding_message_size = self.max_encoding_message_size;
1083 let inner = self.inner.clone();
1084 let fut = async move {
1085 let inner = inner.0;
1086 let method = QuerySigningRequestsSvc(inner);
1087 let codec = tonic::codec::ProstCodec::default();
1088 let mut grpc = tonic::server::Grpc::new(codec)
1089 .apply_compression_config(
1090 accept_compression_encodings,
1091 send_compression_encodings,
1092 )
1093 .apply_max_message_size_config(
1094 max_decoding_message_size,
1095 max_encoding_message_size,
1096 );
1097 let res = grpc.unary(method, req).await;
1098 Ok(res)
1099 };
1100 Box::pin(fut)
1101 }
1102 "/side.btcbridge.Query/QuerySigningRequestsByAddress" => {
1103 #[allow(non_camel_case_types)]
1104 struct QuerySigningRequestsByAddressSvc<T: Query>(pub Arc<T>);
1105 impl<T: Query>
1106 tonic::server::UnaryService<super::QuerySigningRequestsByAddressRequest>
1107 for QuerySigningRequestsByAddressSvc<T>
1108 {
1109 type Response = super::QuerySigningRequestsByAddressResponse;
1110 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1111 fn call(
1112 &mut self,
1113 request: tonic::Request<super::QuerySigningRequestsByAddressRequest>,
1114 ) -> Self::Future {
1115 let inner = Arc::clone(&self.0);
1116 let fut = async move {
1117 (*inner).query_signing_requests_by_address(request).await
1118 };
1119 Box::pin(fut)
1120 }
1121 }
1122 let accept_compression_encodings = self.accept_compression_encodings;
1123 let send_compression_encodings = self.send_compression_encodings;
1124 let max_decoding_message_size = self.max_decoding_message_size;
1125 let max_encoding_message_size = self.max_encoding_message_size;
1126 let inner = self.inner.clone();
1127 let fut = async move {
1128 let inner = inner.0;
1129 let method = QuerySigningRequestsByAddressSvc(inner);
1130 let codec = tonic::codec::ProstCodec::default();
1131 let mut grpc = tonic::server::Grpc::new(codec)
1132 .apply_compression_config(
1133 accept_compression_encodings,
1134 send_compression_encodings,
1135 )
1136 .apply_max_message_size_config(
1137 max_decoding_message_size,
1138 max_encoding_message_size,
1139 );
1140 let res = grpc.unary(method, req).await;
1141 Ok(res)
1142 };
1143 Box::pin(fut)
1144 }
1145 "/side.btcbridge.Query/QuerySigningRequestByTxHash" => {
1146 #[allow(non_camel_case_types)]
1147 struct QuerySigningRequestByTxHashSvc<T: Query>(pub Arc<T>);
1148 impl<T: Query>
1149 tonic::server::UnaryService<super::QuerySigningRequestByTxHashRequest>
1150 for QuerySigningRequestByTxHashSvc<T>
1151 {
1152 type Response = super::QuerySigningRequestByTxHashResponse;
1153 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1154 fn call(
1155 &mut self,
1156 request: tonic::Request<super::QuerySigningRequestByTxHashRequest>,
1157 ) -> Self::Future {
1158 let inner = Arc::clone(&self.0);
1159 let fut = async move {
1160 (*inner).query_signing_request_by_tx_hash(request).await
1161 };
1162 Box::pin(fut)
1163 }
1164 }
1165 let accept_compression_encodings = self.accept_compression_encodings;
1166 let send_compression_encodings = self.send_compression_encodings;
1167 let max_decoding_message_size = self.max_decoding_message_size;
1168 let max_encoding_message_size = self.max_encoding_message_size;
1169 let inner = self.inner.clone();
1170 let fut = async move {
1171 let inner = inner.0;
1172 let method = QuerySigningRequestByTxHashSvc(inner);
1173 let codec = tonic::codec::ProstCodec::default();
1174 let mut grpc = tonic::server::Grpc::new(codec)
1175 .apply_compression_config(
1176 accept_compression_encodings,
1177 send_compression_encodings,
1178 )
1179 .apply_max_message_size_config(
1180 max_decoding_message_size,
1181 max_encoding_message_size,
1182 );
1183 let res = grpc.unary(method, req).await;
1184 Ok(res)
1185 };
1186 Box::pin(fut)
1187 }
1188 "/side.btcbridge.Query/QueryUTXOs" => {
1189 #[allow(non_camel_case_types)]
1190 struct QueryUTXOsSvc<T: Query>(pub Arc<T>);
1191 impl<T: Query> tonic::server::UnaryService<super::QueryUtxOsRequest> for QueryUTXOsSvc<T> {
1192 type Response = super::QueryUtxOsResponse;
1193 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1194 fn call(
1195 &mut self,
1196 request: tonic::Request<super::QueryUtxOsRequest>,
1197 ) -> Self::Future {
1198 let inner = Arc::clone(&self.0);
1199 let fut = async move { (*inner).query_utx_os(request).await };
1200 Box::pin(fut)
1201 }
1202 }
1203 let accept_compression_encodings = self.accept_compression_encodings;
1204 let send_compression_encodings = self.send_compression_encodings;
1205 let max_decoding_message_size = self.max_decoding_message_size;
1206 let max_encoding_message_size = self.max_encoding_message_size;
1207 let inner = self.inner.clone();
1208 let fut = async move {
1209 let inner = inner.0;
1210 let method = QueryUTXOsSvc(inner);
1211 let codec = tonic::codec::ProstCodec::default();
1212 let mut grpc = tonic::server::Grpc::new(codec)
1213 .apply_compression_config(
1214 accept_compression_encodings,
1215 send_compression_encodings,
1216 )
1217 .apply_max_message_size_config(
1218 max_decoding_message_size,
1219 max_encoding_message_size,
1220 );
1221 let res = grpc.unary(method, req).await;
1222 Ok(res)
1223 };
1224 Box::pin(fut)
1225 }
1226 "/side.btcbridge.Query/QueryUTXOsByAddress" => {
1227 #[allow(non_camel_case_types)]
1228 struct QueryUTXOsByAddressSvc<T: Query>(pub Arc<T>);
1229 impl<T: Query> tonic::server::UnaryService<super::QueryUtxOsByAddressRequest>
1230 for QueryUTXOsByAddressSvc<T>
1231 {
1232 type Response = super::QueryUtxOsByAddressResponse;
1233 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1234 fn call(
1235 &mut self,
1236 request: tonic::Request<super::QueryUtxOsByAddressRequest>,
1237 ) -> Self::Future {
1238 let inner = Arc::clone(&self.0);
1239 let fut =
1240 async move { (*inner).query_utx_os_by_address(request).await };
1241 Box::pin(fut)
1242 }
1243 }
1244 let accept_compression_encodings = self.accept_compression_encodings;
1245 let send_compression_encodings = self.send_compression_encodings;
1246 let max_decoding_message_size = self.max_decoding_message_size;
1247 let max_encoding_message_size = self.max_encoding_message_size;
1248 let inner = self.inner.clone();
1249 let fut = async move {
1250 let inner = inner.0;
1251 let method = QueryUTXOsByAddressSvc(inner);
1252 let codec = tonic::codec::ProstCodec::default();
1253 let mut grpc = tonic::server::Grpc::new(codec)
1254 .apply_compression_config(
1255 accept_compression_encodings,
1256 send_compression_encodings,
1257 )
1258 .apply_max_message_size_config(
1259 max_decoding_message_size,
1260 max_encoding_message_size,
1261 );
1262 let res = grpc.unary(method, req).await;
1263 Ok(res)
1264 };
1265 Box::pin(fut)
1266 }
1267 "/side.btcbridge.Query/QueryUTXOCountAndBalancesByAddress" => {
1268 #[allow(non_camel_case_types)]
1269 struct QueryUTXOCountAndBalancesByAddressSvc<T: Query>(pub Arc<T>);
1270 impl<T: Query>
1271 tonic::server::UnaryService<
1272 super::QueryUtxoCountAndBalancesByAddressRequest,
1273 > for QueryUTXOCountAndBalancesByAddressSvc<T>
1274 {
1275 type Response = super::QueryUtxoCountAndBalancesByAddressResponse;
1276 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1277 fn call(
1278 &mut self,
1279 request: tonic::Request<
1280 super::QueryUtxoCountAndBalancesByAddressRequest,
1281 >,
1282 ) -> Self::Future {
1283 let inner = Arc::clone(&self.0);
1284 let fut = async move {
1285 (*inner)
1286 .query_utxo_count_and_balances_by_address(request)
1287 .await
1288 };
1289 Box::pin(fut)
1290 }
1291 }
1292 let accept_compression_encodings = self.accept_compression_encodings;
1293 let send_compression_encodings = self.send_compression_encodings;
1294 let max_decoding_message_size = self.max_decoding_message_size;
1295 let max_encoding_message_size = self.max_encoding_message_size;
1296 let inner = self.inner.clone();
1297 let fut = async move {
1298 let inner = inner.0;
1299 let method = QueryUTXOCountAndBalancesByAddressSvc(inner);
1300 let codec = tonic::codec::ProstCodec::default();
1301 let mut grpc = tonic::server::Grpc::new(codec)
1302 .apply_compression_config(
1303 accept_compression_encodings,
1304 send_compression_encodings,
1305 )
1306 .apply_max_message_size_config(
1307 max_decoding_message_size,
1308 max_encoding_message_size,
1309 );
1310 let res = grpc.unary(method, req).await;
1311 Ok(res)
1312 };
1313 Box::pin(fut)
1314 }
1315 "/side.btcbridge.Query/QueryDKGRequest" => {
1316 #[allow(non_camel_case_types)]
1317 struct QueryDKGRequestSvc<T: Query>(pub Arc<T>);
1318 impl<T: Query> tonic::server::UnaryService<super::QueryDkgRequestRequest>
1319 for QueryDKGRequestSvc<T>
1320 {
1321 type Response = super::QueryDkgRequestResponse;
1322 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1323 fn call(
1324 &mut self,
1325 request: tonic::Request<super::QueryDkgRequestRequest>,
1326 ) -> Self::Future {
1327 let inner = Arc::clone(&self.0);
1328 let fut = async move { (*inner).query_dkg_request(request).await };
1329 Box::pin(fut)
1330 }
1331 }
1332 let accept_compression_encodings = self.accept_compression_encodings;
1333 let send_compression_encodings = self.send_compression_encodings;
1334 let max_decoding_message_size = self.max_decoding_message_size;
1335 let max_encoding_message_size = self.max_encoding_message_size;
1336 let inner = self.inner.clone();
1337 let fut = async move {
1338 let inner = inner.0;
1339 let method = QueryDKGRequestSvc(inner);
1340 let codec = tonic::codec::ProstCodec::default();
1341 let mut grpc = tonic::server::Grpc::new(codec)
1342 .apply_compression_config(
1343 accept_compression_encodings,
1344 send_compression_encodings,
1345 )
1346 .apply_max_message_size_config(
1347 max_decoding_message_size,
1348 max_encoding_message_size,
1349 );
1350 let res = grpc.unary(method, req).await;
1351 Ok(res)
1352 };
1353 Box::pin(fut)
1354 }
1355 "/side.btcbridge.Query/QueryDKGRequests" => {
1356 #[allow(non_camel_case_types)]
1357 struct QueryDKGRequestsSvc<T: Query>(pub Arc<T>);
1358 impl<T: Query> tonic::server::UnaryService<super::QueryDkgRequestsRequest>
1359 for QueryDKGRequestsSvc<T>
1360 {
1361 type Response = super::QueryDkgRequestsResponse;
1362 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1363 fn call(
1364 &mut self,
1365 request: tonic::Request<super::QueryDkgRequestsRequest>,
1366 ) -> Self::Future {
1367 let inner = Arc::clone(&self.0);
1368 let fut = async move { (*inner).query_dkg_requests(request).await };
1369 Box::pin(fut)
1370 }
1371 }
1372 let accept_compression_encodings = self.accept_compression_encodings;
1373 let send_compression_encodings = self.send_compression_encodings;
1374 let max_decoding_message_size = self.max_decoding_message_size;
1375 let max_encoding_message_size = self.max_encoding_message_size;
1376 let inner = self.inner.clone();
1377 let fut = async move {
1378 let inner = inner.0;
1379 let method = QueryDKGRequestsSvc(inner);
1380 let codec = tonic::codec::ProstCodec::default();
1381 let mut grpc = tonic::server::Grpc::new(codec)
1382 .apply_compression_config(
1383 accept_compression_encodings,
1384 send_compression_encodings,
1385 )
1386 .apply_max_message_size_config(
1387 max_decoding_message_size,
1388 max_encoding_message_size,
1389 );
1390 let res = grpc.unary(method, req).await;
1391 Ok(res)
1392 };
1393 Box::pin(fut)
1394 }
1395 "/side.btcbridge.Query/QueryAllDKGRequests" => {
1396 #[allow(non_camel_case_types)]
1397 struct QueryAllDKGRequestsSvc<T: Query>(pub Arc<T>);
1398 impl<T: Query> tonic::server::UnaryService<super::QueryAllDkgRequestsRequest>
1399 for QueryAllDKGRequestsSvc<T>
1400 {
1401 type Response = super::QueryAllDkgRequestsResponse;
1402 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1403 fn call(
1404 &mut self,
1405 request: tonic::Request<super::QueryAllDkgRequestsRequest>,
1406 ) -> Self::Future {
1407 let inner = Arc::clone(&self.0);
1408 let fut = async move { (*inner).query_all_dkg_requests(request).await };
1409 Box::pin(fut)
1410 }
1411 }
1412 let accept_compression_encodings = self.accept_compression_encodings;
1413 let send_compression_encodings = self.send_compression_encodings;
1414 let max_decoding_message_size = self.max_decoding_message_size;
1415 let max_encoding_message_size = self.max_encoding_message_size;
1416 let inner = self.inner.clone();
1417 let fut = async move {
1418 let inner = inner.0;
1419 let method = QueryAllDKGRequestsSvc(inner);
1420 let codec = tonic::codec::ProstCodec::default();
1421 let mut grpc = tonic::server::Grpc::new(codec)
1422 .apply_compression_config(
1423 accept_compression_encodings,
1424 send_compression_encodings,
1425 )
1426 .apply_max_message_size_config(
1427 max_decoding_message_size,
1428 max_encoding_message_size,
1429 );
1430 let res = grpc.unary(method, req).await;
1431 Ok(res)
1432 };
1433 Box::pin(fut)
1434 }
1435 "/side.btcbridge.Query/QueryDKGCompletionRequests" => {
1436 #[allow(non_camel_case_types)]
1437 struct QueryDKGCompletionRequestsSvc<T: Query>(pub Arc<T>);
1438 impl<T: Query>
1439 tonic::server::UnaryService<super::QueryDkgCompletionRequestsRequest>
1440 for QueryDKGCompletionRequestsSvc<T>
1441 {
1442 type Response = super::QueryDkgCompletionRequestsResponse;
1443 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1444 fn call(
1445 &mut self,
1446 request: tonic::Request<super::QueryDkgCompletionRequestsRequest>,
1447 ) -> Self::Future {
1448 let inner = Arc::clone(&self.0);
1449 let fut = async move {
1450 (*inner).query_dkg_completion_requests(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 = QueryDKGCompletionRequestsSvc(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 _ => Box::pin(async move {
1479 Ok(http::Response::builder()
1480 .status(200)
1481 .header("grpc-status", "12")
1482 .header("content-type", "application/grpc")
1483 .body(empty_body())
1484 .unwrap())
1485 }),
1486 }
1487 }
1488 }
1489 impl<T: Query> Clone for QueryServer<T> {
1490 fn clone(&self) -> Self {
1491 let inner = self.inner.clone();
1492 Self {
1493 inner,
1494 accept_compression_encodings: self.accept_compression_encodings,
1495 send_compression_encodings: self.send_compression_encodings,
1496 max_decoding_message_size: self.max_decoding_message_size,
1497 max_encoding_message_size: self.max_encoding_message_size,
1498 }
1499 }
1500 }
1501 impl<T: Query> Clone for _Inner<T> {
1502 fn clone(&self) -> Self {
1503 Self(Arc::clone(&self.0))
1504 }
1505 }
1506 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
1507 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1508 write!(f, "{:?}", self.0)
1509 }
1510 }
1511 impl<T: Query> tonic::server::NamedService for QueryServer<T> {
1512 const NAME: &'static str = "side.btcbridge.Query";
1513 }
1514}
1515#[cfg(feature = "grpc")]
1517pub mod msg_client {
1518 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1519 use tonic::codegen::http::Uri;
1520 use tonic::codegen::*;
1521 #[derive(Debug, Clone)]
1522 pub struct MsgClient<T> {
1523 inner: tonic::client::Grpc<T>,
1524 }
1525 #[cfg(feature = "grpc-transport")]
1526 impl MsgClient<tonic::transport::Channel> {
1527 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1529 where
1530 D: TryInto<tonic::transport::Endpoint>,
1531 D::Error: Into<StdError>,
1532 {
1533 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1534 Ok(Self::new(conn))
1535 }
1536 }
1537 impl<T> MsgClient<T>
1538 where
1539 T: tonic::client::GrpcService<tonic::body::BoxBody>,
1540 T::Error: Into<StdError>,
1541 T::ResponseBody: Body<Data = Bytes> + Send + 'static,
1542 <T::ResponseBody as Body>::Error: Into<StdError> + Send,
1543 {
1544 pub fn new(inner: T) -> Self {
1545 let inner = tonic::client::Grpc::new(inner);
1546 Self { inner }
1547 }
1548 pub fn with_origin(inner: T, origin: Uri) -> Self {
1549 let inner = tonic::client::Grpc::with_origin(inner, origin);
1550 Self { inner }
1551 }
1552 pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
1553 where
1554 F: tonic::service::Interceptor,
1555 T::ResponseBody: Default,
1556 T: tonic::codegen::Service<
1557 http::Request<tonic::body::BoxBody>,
1558 Response = http::Response<
1559 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1560 >,
1561 >,
1562 <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
1563 Into<StdError> + Send + Sync,
1564 {
1565 MsgClient::new(InterceptedService::new(inner, interceptor))
1566 }
1567 #[must_use]
1572 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1573 self.inner = self.inner.send_compressed(encoding);
1574 self
1575 }
1576 #[must_use]
1578 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1579 self.inner = self.inner.accept_compressed(encoding);
1580 self
1581 }
1582 #[must_use]
1586 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1587 self.inner = self.inner.max_decoding_message_size(limit);
1588 self
1589 }
1590 #[must_use]
1594 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1595 self.inner = self.inner.max_encoding_message_size(limit);
1596 self
1597 }
1598 pub async fn submit_block_headers(
1599 &mut self,
1600 request: impl tonic::IntoRequest<super::MsgSubmitBlockHeaders>,
1601 ) -> core::result::Result<
1602 tonic::Response<super::MsgSubmitBlockHeadersResponse>,
1603 tonic::Status,
1604 > {
1605 self.inner.ready().await.map_err(|e| {
1606 tonic::Status::new(
1607 tonic::Code::Unknown,
1608 alloc::format!("Service was not ready: {}", e.into()),
1609 )
1610 })?;
1611 let codec = tonic::codec::ProstCodec::default();
1612 let path =
1613 http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/SubmitBlockHeaders");
1614 let mut req = request.into_request();
1615 req.extensions_mut()
1616 .insert(GrpcMethod::new("side.btcbridge.Msg", "SubmitBlockHeaders"));
1617 self.inner.unary(req, path, codec).await
1618 }
1619 pub async fn submit_deposit_transaction(
1620 &mut self,
1621 request: impl tonic::IntoRequest<super::MsgSubmitDepositTransaction>,
1622 ) -> core::result::Result<
1623 tonic::Response<super::MsgSubmitDepositTransactionResponse>,
1624 tonic::Status,
1625 > {
1626 self.inner.ready().await.map_err(|e| {
1627 tonic::Status::new(
1628 tonic::Code::Unknown,
1629 alloc::format!("Service was not ready: {}", e.into()),
1630 )
1631 })?;
1632 let codec = tonic::codec::ProstCodec::default();
1633 let path = http::uri::PathAndQuery::from_static(
1634 "/side.btcbridge.Msg/SubmitDepositTransaction",
1635 );
1636 let mut req = request.into_request();
1637 req.extensions_mut().insert(GrpcMethod::new(
1638 "side.btcbridge.Msg",
1639 "SubmitDepositTransaction",
1640 ));
1641 self.inner.unary(req, path, codec).await
1642 }
1643 pub async fn submit_withdraw_transaction(
1644 &mut self,
1645 request: impl tonic::IntoRequest<super::MsgSubmitWithdrawTransaction>,
1646 ) -> core::result::Result<
1647 tonic::Response<super::MsgSubmitWithdrawTransactionResponse>,
1648 tonic::Status,
1649 > {
1650 self.inner.ready().await.map_err(|e| {
1651 tonic::Status::new(
1652 tonic::Code::Unknown,
1653 alloc::format!("Service was not ready: {}", e.into()),
1654 )
1655 })?;
1656 let codec = tonic::codec::ProstCodec::default();
1657 let path = http::uri::PathAndQuery::from_static(
1658 "/side.btcbridge.Msg/SubmitWithdrawTransaction",
1659 );
1660 let mut req = request.into_request();
1661 req.extensions_mut().insert(GrpcMethod::new(
1662 "side.btcbridge.Msg",
1663 "SubmitWithdrawTransaction",
1664 ));
1665 self.inner.unary(req, path, codec).await
1666 }
1667 pub async fn submit_fee_rate(
1668 &mut self,
1669 request: impl tonic::IntoRequest<super::MsgSubmitFeeRate>,
1670 ) -> core::result::Result<tonic::Response<super::MsgSubmitFeeRateResponse>, tonic::Status>
1671 {
1672 self.inner.ready().await.map_err(|e| {
1673 tonic::Status::new(
1674 tonic::Code::Unknown,
1675 alloc::format!("Service was not ready: {}", e.into()),
1676 )
1677 })?;
1678 let codec = tonic::codec::ProstCodec::default();
1679 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/SubmitFeeRate");
1680 let mut req = request.into_request();
1681 req.extensions_mut()
1682 .insert(GrpcMethod::new("side.btcbridge.Msg", "SubmitFeeRate"));
1683 self.inner.unary(req, path, codec).await
1684 }
1685 pub async fn update_trusted_non_btc_relayers(
1686 &mut self,
1687 request: impl tonic::IntoRequest<super::MsgUpdateTrustedNonBtcRelayers>,
1688 ) -> core::result::Result<
1689 tonic::Response<super::MsgUpdateTrustedNonBtcRelayersResponse>,
1690 tonic::Status,
1691 > {
1692 self.inner.ready().await.map_err(|e| {
1693 tonic::Status::new(
1694 tonic::Code::Unknown,
1695 alloc::format!("Service was not ready: {}", e.into()),
1696 )
1697 })?;
1698 let codec = tonic::codec::ProstCodec::default();
1699 let path = http::uri::PathAndQuery::from_static(
1700 "/side.btcbridge.Msg/UpdateTrustedNonBtcRelayers",
1701 );
1702 let mut req = request.into_request();
1703 req.extensions_mut().insert(GrpcMethod::new(
1704 "side.btcbridge.Msg",
1705 "UpdateTrustedNonBtcRelayers",
1706 ));
1707 self.inner.unary(req, path, codec).await
1708 }
1709 pub async fn update_trusted_oracles(
1710 &mut self,
1711 request: impl tonic::IntoRequest<super::MsgUpdateTrustedOracles>,
1712 ) -> core::result::Result<
1713 tonic::Response<super::MsgUpdateTrustedOraclesResponse>,
1714 tonic::Status,
1715 > {
1716 self.inner.ready().await.map_err(|e| {
1717 tonic::Status::new(
1718 tonic::Code::Unknown,
1719 alloc::format!("Service was not ready: {}", e.into()),
1720 )
1721 })?;
1722 let codec = tonic::codec::ProstCodec::default();
1723 let path =
1724 http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/UpdateTrustedOracles");
1725 let mut req = request.into_request();
1726 req.extensions_mut().insert(GrpcMethod::new(
1727 "side.btcbridge.Msg",
1728 "UpdateTrustedOracles",
1729 ));
1730 self.inner.unary(req, path, codec).await
1731 }
1732 pub async fn withdraw_to_bitcoin(
1733 &mut self,
1734 request: impl tonic::IntoRequest<super::MsgWithdrawToBitcoin>,
1735 ) -> core::result::Result<tonic::Response<super::MsgWithdrawToBitcoinResponse>, tonic::Status>
1736 {
1737 self.inner.ready().await.map_err(|e| {
1738 tonic::Status::new(
1739 tonic::Code::Unknown,
1740 alloc::format!("Service was not ready: {}", e.into()),
1741 )
1742 })?;
1743 let codec = tonic::codec::ProstCodec::default();
1744 let path =
1745 http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/WithdrawToBitcoin");
1746 let mut req = request.into_request();
1747 req.extensions_mut()
1748 .insert(GrpcMethod::new("side.btcbridge.Msg", "WithdrawToBitcoin"));
1749 self.inner.unary(req, path, codec).await
1750 }
1751 pub async fn submit_signatures(
1752 &mut self,
1753 request: impl tonic::IntoRequest<super::MsgSubmitSignatures>,
1754 ) -> core::result::Result<tonic::Response<super::MsgSubmitSignaturesResponse>, tonic::Status>
1755 {
1756 self.inner.ready().await.map_err(|e| {
1757 tonic::Status::new(
1758 tonic::Code::Unknown,
1759 alloc::format!("Service was not ready: {}", e.into()),
1760 )
1761 })?;
1762 let codec = tonic::codec::ProstCodec::default();
1763 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/SubmitSignatures");
1764 let mut req = request.into_request();
1765 req.extensions_mut()
1766 .insert(GrpcMethod::new("side.btcbridge.Msg", "SubmitSignatures"));
1767 self.inner.unary(req, path, codec).await
1768 }
1769 pub async fn consolidate_vaults(
1770 &mut self,
1771 request: impl tonic::IntoRequest<super::MsgConsolidateVaults>,
1772 ) -> core::result::Result<tonic::Response<super::MsgConsolidateVaultsResponse>, tonic::Status>
1773 {
1774 self.inner.ready().await.map_err(|e| {
1775 tonic::Status::new(
1776 tonic::Code::Unknown,
1777 alloc::format!("Service was not ready: {}", e.into()),
1778 )
1779 })?;
1780 let codec = tonic::codec::ProstCodec::default();
1781 let path =
1782 http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/ConsolidateVaults");
1783 let mut req = request.into_request();
1784 req.extensions_mut()
1785 .insert(GrpcMethod::new("side.btcbridge.Msg", "ConsolidateVaults"));
1786 self.inner.unary(req, path, codec).await
1787 }
1788 pub async fn initiate_dkg(
1789 &mut self,
1790 request: impl tonic::IntoRequest<super::MsgInitiateDkg>,
1791 ) -> core::result::Result<tonic::Response<super::MsgInitiateDkgResponse>, tonic::Status>
1792 {
1793 self.inner.ready().await.map_err(|e| {
1794 tonic::Status::new(
1795 tonic::Code::Unknown,
1796 alloc::format!("Service was not ready: {}", e.into()),
1797 )
1798 })?;
1799 let codec = tonic::codec::ProstCodec::default();
1800 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/InitiateDKG");
1801 let mut req = request.into_request();
1802 req.extensions_mut()
1803 .insert(GrpcMethod::new("side.btcbridge.Msg", "InitiateDKG"));
1804 self.inner.unary(req, path, codec).await
1805 }
1806 pub async fn complete_dkg(
1807 &mut self,
1808 request: impl tonic::IntoRequest<super::MsgCompleteDkg>,
1809 ) -> core::result::Result<tonic::Response<super::MsgCompleteDkgResponse>, tonic::Status>
1810 {
1811 self.inner.ready().await.map_err(|e| {
1812 tonic::Status::new(
1813 tonic::Code::Unknown,
1814 alloc::format!("Service was not ready: {}", e.into()),
1815 )
1816 })?;
1817 let codec = tonic::codec::ProstCodec::default();
1818 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/CompleteDKG");
1819 let mut req = request.into_request();
1820 req.extensions_mut()
1821 .insert(GrpcMethod::new("side.btcbridge.Msg", "CompleteDKG"));
1822 self.inner.unary(req, path, codec).await
1823 }
1824 pub async fn transfer_vault(
1825 &mut self,
1826 request: impl tonic::IntoRequest<super::MsgTransferVault>,
1827 ) -> core::result::Result<tonic::Response<super::MsgTransferVaultResponse>, tonic::Status>
1828 {
1829 self.inner.ready().await.map_err(|e| {
1830 tonic::Status::new(
1831 tonic::Code::Unknown,
1832 alloc::format!("Service was not ready: {}", e.into()),
1833 )
1834 })?;
1835 let codec = tonic::codec::ProstCodec::default();
1836 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/TransferVault");
1837 let mut req = request.into_request();
1838 req.extensions_mut()
1839 .insert(GrpcMethod::new("side.btcbridge.Msg", "TransferVault"));
1840 self.inner.unary(req, path, codec).await
1841 }
1842 pub async fn update_params(
1843 &mut self,
1844 request: impl tonic::IntoRequest<super::MsgUpdateParams>,
1845 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>
1846 {
1847 self.inner.ready().await.map_err(|e| {
1848 tonic::Status::new(
1849 tonic::Code::Unknown,
1850 alloc::format!("Service was not ready: {}", e.into()),
1851 )
1852 })?;
1853 let codec = tonic::codec::ProstCodec::default();
1854 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/UpdateParams");
1855 let mut req = request.into_request();
1856 req.extensions_mut()
1857 .insert(GrpcMethod::new("side.btcbridge.Msg", "UpdateParams"));
1858 self.inner.unary(req, path, codec).await
1859 }
1860 }
1861}
1862#[cfg(feature = "grpc")]
1864pub mod msg_server {
1865 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1866 use tonic::codegen::*;
1867 #[async_trait]
1869 pub trait Msg: Send + Sync + 'static {
1870 async fn submit_block_headers(
1871 &self,
1872 request: tonic::Request<super::MsgSubmitBlockHeaders>,
1873 ) -> core::result::Result<
1874 tonic::Response<super::MsgSubmitBlockHeadersResponse>,
1875 tonic::Status,
1876 >;
1877 async fn submit_deposit_transaction(
1878 &self,
1879 request: tonic::Request<super::MsgSubmitDepositTransaction>,
1880 ) -> core::result::Result<
1881 tonic::Response<super::MsgSubmitDepositTransactionResponse>,
1882 tonic::Status,
1883 >;
1884 async fn submit_withdraw_transaction(
1885 &self,
1886 request: tonic::Request<super::MsgSubmitWithdrawTransaction>,
1887 ) -> core::result::Result<
1888 tonic::Response<super::MsgSubmitWithdrawTransactionResponse>,
1889 tonic::Status,
1890 >;
1891 async fn submit_fee_rate(
1892 &self,
1893 request: tonic::Request<super::MsgSubmitFeeRate>,
1894 ) -> core::result::Result<tonic::Response<super::MsgSubmitFeeRateResponse>, tonic::Status>;
1895 async fn update_trusted_non_btc_relayers(
1896 &self,
1897 request: tonic::Request<super::MsgUpdateTrustedNonBtcRelayers>,
1898 ) -> core::result::Result<
1899 tonic::Response<super::MsgUpdateTrustedNonBtcRelayersResponse>,
1900 tonic::Status,
1901 >;
1902 async fn update_trusted_oracles(
1903 &self,
1904 request: tonic::Request<super::MsgUpdateTrustedOracles>,
1905 ) -> core::result::Result<
1906 tonic::Response<super::MsgUpdateTrustedOraclesResponse>,
1907 tonic::Status,
1908 >;
1909 async fn withdraw_to_bitcoin(
1910 &self,
1911 request: tonic::Request<super::MsgWithdrawToBitcoin>,
1912 ) -> core::result::Result<tonic::Response<super::MsgWithdrawToBitcoinResponse>, tonic::Status>;
1913 async fn submit_signatures(
1914 &self,
1915 request: tonic::Request<super::MsgSubmitSignatures>,
1916 ) -> core::result::Result<tonic::Response<super::MsgSubmitSignaturesResponse>, tonic::Status>;
1917 async fn consolidate_vaults(
1918 &self,
1919 request: tonic::Request<super::MsgConsolidateVaults>,
1920 ) -> core::result::Result<tonic::Response<super::MsgConsolidateVaultsResponse>, tonic::Status>;
1921 async fn initiate_dkg(
1922 &self,
1923 request: tonic::Request<super::MsgInitiateDkg>,
1924 ) -> core::result::Result<tonic::Response<super::MsgInitiateDkgResponse>, tonic::Status>;
1925 async fn complete_dkg(
1926 &self,
1927 request: tonic::Request<super::MsgCompleteDkg>,
1928 ) -> core::result::Result<tonic::Response<super::MsgCompleteDkgResponse>, tonic::Status>;
1929 async fn transfer_vault(
1930 &self,
1931 request: tonic::Request<super::MsgTransferVault>,
1932 ) -> core::result::Result<tonic::Response<super::MsgTransferVaultResponse>, tonic::Status>;
1933 async fn update_params(
1934 &self,
1935 request: tonic::Request<super::MsgUpdateParams>,
1936 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>;
1937 }
1938 #[derive(Debug)]
1939 pub struct MsgServer<T: Msg> {
1940 inner: _Inner<T>,
1941 accept_compression_encodings: EnabledCompressionEncodings,
1942 send_compression_encodings: EnabledCompressionEncodings,
1943 max_decoding_message_size: Option<usize>,
1944 max_encoding_message_size: Option<usize>,
1945 }
1946 struct _Inner<T>(Arc<T>);
1947 impl<T: Msg> MsgServer<T> {
1948 pub fn new(inner: T) -> Self {
1949 Self::from_arc(Arc::new(inner))
1950 }
1951 pub fn from_arc(inner: Arc<T>) -> Self {
1952 let inner = _Inner(inner);
1953 Self {
1954 inner,
1955 accept_compression_encodings: Default::default(),
1956 send_compression_encodings: Default::default(),
1957 max_decoding_message_size: None,
1958 max_encoding_message_size: None,
1959 }
1960 }
1961 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1962 where
1963 F: tonic::service::Interceptor,
1964 {
1965 InterceptedService::new(Self::new(inner), interceptor)
1966 }
1967 #[must_use]
1969 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1970 self.accept_compression_encodings.enable(encoding);
1971 self
1972 }
1973 #[must_use]
1975 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1976 self.send_compression_encodings.enable(encoding);
1977 self
1978 }
1979 #[must_use]
1983 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1984 self.max_decoding_message_size = Some(limit);
1985 self
1986 }
1987 #[must_use]
1991 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1992 self.max_encoding_message_size = Some(limit);
1993 self
1994 }
1995 }
1996 impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
1997 where
1998 T: Msg,
1999 B: Body + Send + 'static,
2000 B::Error: Into<StdError> + Send + 'static,
2001 {
2002 type Response = http::Response<tonic::body::BoxBody>;
2003 type Error = std::convert::Infallible;
2004 type Future = BoxFuture<Self::Response, Self::Error>;
2005 fn poll_ready(
2006 &mut self,
2007 _cx: &mut Context<'_>,
2008 ) -> Poll<core::result::Result<(), Self::Error>> {
2009 Poll::Ready(Ok(()))
2010 }
2011 fn call(&mut self, req: http::Request<B>) -> Self::Future {
2012 let inner = self.inner.clone();
2013 match req.uri().path() {
2014 "/side.btcbridge.Msg/SubmitBlockHeaders" => {
2015 #[allow(non_camel_case_types)]
2016 struct SubmitBlockHeadersSvc<T: Msg>(pub Arc<T>);
2017 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitBlockHeaders>
2018 for SubmitBlockHeadersSvc<T>
2019 {
2020 type Response = super::MsgSubmitBlockHeadersResponse;
2021 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2022 fn call(
2023 &mut self,
2024 request: tonic::Request<super::MsgSubmitBlockHeaders>,
2025 ) -> Self::Future {
2026 let inner = Arc::clone(&self.0);
2027 let fut = async move { (*inner).submit_block_headers(request).await };
2028 Box::pin(fut)
2029 }
2030 }
2031 let accept_compression_encodings = self.accept_compression_encodings;
2032 let send_compression_encodings = self.send_compression_encodings;
2033 let max_decoding_message_size = self.max_decoding_message_size;
2034 let max_encoding_message_size = self.max_encoding_message_size;
2035 let inner = self.inner.clone();
2036 let fut = async move {
2037 let inner = inner.0;
2038 let method = SubmitBlockHeadersSvc(inner);
2039 let codec = tonic::codec::ProstCodec::default();
2040 let mut grpc = tonic::server::Grpc::new(codec)
2041 .apply_compression_config(
2042 accept_compression_encodings,
2043 send_compression_encodings,
2044 )
2045 .apply_max_message_size_config(
2046 max_decoding_message_size,
2047 max_encoding_message_size,
2048 );
2049 let res = grpc.unary(method, req).await;
2050 Ok(res)
2051 };
2052 Box::pin(fut)
2053 }
2054 "/side.btcbridge.Msg/SubmitDepositTransaction" => {
2055 #[allow(non_camel_case_types)]
2056 struct SubmitDepositTransactionSvc<T: Msg>(pub Arc<T>);
2057 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitDepositTransaction>
2058 for SubmitDepositTransactionSvc<T>
2059 {
2060 type Response = super::MsgSubmitDepositTransactionResponse;
2061 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2062 fn call(
2063 &mut self,
2064 request: tonic::Request<super::MsgSubmitDepositTransaction>,
2065 ) -> Self::Future {
2066 let inner = Arc::clone(&self.0);
2067 let fut =
2068 async move { (*inner).submit_deposit_transaction(request).await };
2069 Box::pin(fut)
2070 }
2071 }
2072 let accept_compression_encodings = self.accept_compression_encodings;
2073 let send_compression_encodings = self.send_compression_encodings;
2074 let max_decoding_message_size = self.max_decoding_message_size;
2075 let max_encoding_message_size = self.max_encoding_message_size;
2076 let inner = self.inner.clone();
2077 let fut = async move {
2078 let inner = inner.0;
2079 let method = SubmitDepositTransactionSvc(inner);
2080 let codec = tonic::codec::ProstCodec::default();
2081 let mut grpc = tonic::server::Grpc::new(codec)
2082 .apply_compression_config(
2083 accept_compression_encodings,
2084 send_compression_encodings,
2085 )
2086 .apply_max_message_size_config(
2087 max_decoding_message_size,
2088 max_encoding_message_size,
2089 );
2090 let res = grpc.unary(method, req).await;
2091 Ok(res)
2092 };
2093 Box::pin(fut)
2094 }
2095 "/side.btcbridge.Msg/SubmitWithdrawTransaction" => {
2096 #[allow(non_camel_case_types)]
2097 struct SubmitWithdrawTransactionSvc<T: Msg>(pub Arc<T>);
2098 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitWithdrawTransaction>
2099 for SubmitWithdrawTransactionSvc<T>
2100 {
2101 type Response = super::MsgSubmitWithdrawTransactionResponse;
2102 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2103 fn call(
2104 &mut self,
2105 request: tonic::Request<super::MsgSubmitWithdrawTransaction>,
2106 ) -> Self::Future {
2107 let inner = Arc::clone(&self.0);
2108 let fut =
2109 async move { (*inner).submit_withdraw_transaction(request).await };
2110 Box::pin(fut)
2111 }
2112 }
2113 let accept_compression_encodings = self.accept_compression_encodings;
2114 let send_compression_encodings = self.send_compression_encodings;
2115 let max_decoding_message_size = self.max_decoding_message_size;
2116 let max_encoding_message_size = self.max_encoding_message_size;
2117 let inner = self.inner.clone();
2118 let fut = async move {
2119 let inner = inner.0;
2120 let method = SubmitWithdrawTransactionSvc(inner);
2121 let codec = tonic::codec::ProstCodec::default();
2122 let mut grpc = tonic::server::Grpc::new(codec)
2123 .apply_compression_config(
2124 accept_compression_encodings,
2125 send_compression_encodings,
2126 )
2127 .apply_max_message_size_config(
2128 max_decoding_message_size,
2129 max_encoding_message_size,
2130 );
2131 let res = grpc.unary(method, req).await;
2132 Ok(res)
2133 };
2134 Box::pin(fut)
2135 }
2136 "/side.btcbridge.Msg/SubmitFeeRate" => {
2137 #[allow(non_camel_case_types)]
2138 struct SubmitFeeRateSvc<T: Msg>(pub Arc<T>);
2139 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitFeeRate> for SubmitFeeRateSvc<T> {
2140 type Response = super::MsgSubmitFeeRateResponse;
2141 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2142 fn call(
2143 &mut self,
2144 request: tonic::Request<super::MsgSubmitFeeRate>,
2145 ) -> Self::Future {
2146 let inner = Arc::clone(&self.0);
2147 let fut = async move { (*inner).submit_fee_rate(request).await };
2148 Box::pin(fut)
2149 }
2150 }
2151 let accept_compression_encodings = self.accept_compression_encodings;
2152 let send_compression_encodings = self.send_compression_encodings;
2153 let max_decoding_message_size = self.max_decoding_message_size;
2154 let max_encoding_message_size = self.max_encoding_message_size;
2155 let inner = self.inner.clone();
2156 let fut = async move {
2157 let inner = inner.0;
2158 let method = SubmitFeeRateSvc(inner);
2159 let codec = tonic::codec::ProstCodec::default();
2160 let mut grpc = tonic::server::Grpc::new(codec)
2161 .apply_compression_config(
2162 accept_compression_encodings,
2163 send_compression_encodings,
2164 )
2165 .apply_max_message_size_config(
2166 max_decoding_message_size,
2167 max_encoding_message_size,
2168 );
2169 let res = grpc.unary(method, req).await;
2170 Ok(res)
2171 };
2172 Box::pin(fut)
2173 }
2174 "/side.btcbridge.Msg/UpdateTrustedNonBtcRelayers" => {
2175 #[allow(non_camel_case_types)]
2176 struct UpdateTrustedNonBtcRelayersSvc<T: Msg>(pub Arc<T>);
2177 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateTrustedNonBtcRelayers>
2178 for UpdateTrustedNonBtcRelayersSvc<T>
2179 {
2180 type Response = super::MsgUpdateTrustedNonBtcRelayersResponse;
2181 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2182 fn call(
2183 &mut self,
2184 request: tonic::Request<super::MsgUpdateTrustedNonBtcRelayers>,
2185 ) -> Self::Future {
2186 let inner = Arc::clone(&self.0);
2187 let fut = async move {
2188 (*inner).update_trusted_non_btc_relayers(request).await
2189 };
2190 Box::pin(fut)
2191 }
2192 }
2193 let accept_compression_encodings = self.accept_compression_encodings;
2194 let send_compression_encodings = self.send_compression_encodings;
2195 let max_decoding_message_size = self.max_decoding_message_size;
2196 let max_encoding_message_size = self.max_encoding_message_size;
2197 let inner = self.inner.clone();
2198 let fut = async move {
2199 let inner = inner.0;
2200 let method = UpdateTrustedNonBtcRelayersSvc(inner);
2201 let codec = tonic::codec::ProstCodec::default();
2202 let mut grpc = tonic::server::Grpc::new(codec)
2203 .apply_compression_config(
2204 accept_compression_encodings,
2205 send_compression_encodings,
2206 )
2207 .apply_max_message_size_config(
2208 max_decoding_message_size,
2209 max_encoding_message_size,
2210 );
2211 let res = grpc.unary(method, req).await;
2212 Ok(res)
2213 };
2214 Box::pin(fut)
2215 }
2216 "/side.btcbridge.Msg/UpdateTrustedOracles" => {
2217 #[allow(non_camel_case_types)]
2218 struct UpdateTrustedOraclesSvc<T: Msg>(pub Arc<T>);
2219 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateTrustedOracles>
2220 for UpdateTrustedOraclesSvc<T>
2221 {
2222 type Response = super::MsgUpdateTrustedOraclesResponse;
2223 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2224 fn call(
2225 &mut self,
2226 request: tonic::Request<super::MsgUpdateTrustedOracles>,
2227 ) -> Self::Future {
2228 let inner = Arc::clone(&self.0);
2229 let fut = async move { (*inner).update_trusted_oracles(request).await };
2230 Box::pin(fut)
2231 }
2232 }
2233 let accept_compression_encodings = self.accept_compression_encodings;
2234 let send_compression_encodings = self.send_compression_encodings;
2235 let max_decoding_message_size = self.max_decoding_message_size;
2236 let max_encoding_message_size = self.max_encoding_message_size;
2237 let inner = self.inner.clone();
2238 let fut = async move {
2239 let inner = inner.0;
2240 let method = UpdateTrustedOraclesSvc(inner);
2241 let codec = tonic::codec::ProstCodec::default();
2242 let mut grpc = tonic::server::Grpc::new(codec)
2243 .apply_compression_config(
2244 accept_compression_encodings,
2245 send_compression_encodings,
2246 )
2247 .apply_max_message_size_config(
2248 max_decoding_message_size,
2249 max_encoding_message_size,
2250 );
2251 let res = grpc.unary(method, req).await;
2252 Ok(res)
2253 };
2254 Box::pin(fut)
2255 }
2256 "/side.btcbridge.Msg/WithdrawToBitcoin" => {
2257 #[allow(non_camel_case_types)]
2258 struct WithdrawToBitcoinSvc<T: Msg>(pub Arc<T>);
2259 impl<T: Msg> tonic::server::UnaryService<super::MsgWithdrawToBitcoin> for WithdrawToBitcoinSvc<T> {
2260 type Response = super::MsgWithdrawToBitcoinResponse;
2261 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2262 fn call(
2263 &mut self,
2264 request: tonic::Request<super::MsgWithdrawToBitcoin>,
2265 ) -> Self::Future {
2266 let inner = Arc::clone(&self.0);
2267 let fut = async move { (*inner).withdraw_to_bitcoin(request).await };
2268 Box::pin(fut)
2269 }
2270 }
2271 let accept_compression_encodings = self.accept_compression_encodings;
2272 let send_compression_encodings = self.send_compression_encodings;
2273 let max_decoding_message_size = self.max_decoding_message_size;
2274 let max_encoding_message_size = self.max_encoding_message_size;
2275 let inner = self.inner.clone();
2276 let fut = async move {
2277 let inner = inner.0;
2278 let method = WithdrawToBitcoinSvc(inner);
2279 let codec = tonic::codec::ProstCodec::default();
2280 let mut grpc = tonic::server::Grpc::new(codec)
2281 .apply_compression_config(
2282 accept_compression_encodings,
2283 send_compression_encodings,
2284 )
2285 .apply_max_message_size_config(
2286 max_decoding_message_size,
2287 max_encoding_message_size,
2288 );
2289 let res = grpc.unary(method, req).await;
2290 Ok(res)
2291 };
2292 Box::pin(fut)
2293 }
2294 "/side.btcbridge.Msg/SubmitSignatures" => {
2295 #[allow(non_camel_case_types)]
2296 struct SubmitSignaturesSvc<T: Msg>(pub Arc<T>);
2297 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitSignatures> for SubmitSignaturesSvc<T> {
2298 type Response = super::MsgSubmitSignaturesResponse;
2299 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2300 fn call(
2301 &mut self,
2302 request: tonic::Request<super::MsgSubmitSignatures>,
2303 ) -> Self::Future {
2304 let inner = Arc::clone(&self.0);
2305 let fut = async move { (*inner).submit_signatures(request).await };
2306 Box::pin(fut)
2307 }
2308 }
2309 let accept_compression_encodings = self.accept_compression_encodings;
2310 let send_compression_encodings = self.send_compression_encodings;
2311 let max_decoding_message_size = self.max_decoding_message_size;
2312 let max_encoding_message_size = self.max_encoding_message_size;
2313 let inner = self.inner.clone();
2314 let fut = async move {
2315 let inner = inner.0;
2316 let method = SubmitSignaturesSvc(inner);
2317 let codec = tonic::codec::ProstCodec::default();
2318 let mut grpc = tonic::server::Grpc::new(codec)
2319 .apply_compression_config(
2320 accept_compression_encodings,
2321 send_compression_encodings,
2322 )
2323 .apply_max_message_size_config(
2324 max_decoding_message_size,
2325 max_encoding_message_size,
2326 );
2327 let res = grpc.unary(method, req).await;
2328 Ok(res)
2329 };
2330 Box::pin(fut)
2331 }
2332 "/side.btcbridge.Msg/ConsolidateVaults" => {
2333 #[allow(non_camel_case_types)]
2334 struct ConsolidateVaultsSvc<T: Msg>(pub Arc<T>);
2335 impl<T: Msg> tonic::server::UnaryService<super::MsgConsolidateVaults> for ConsolidateVaultsSvc<T> {
2336 type Response = super::MsgConsolidateVaultsResponse;
2337 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2338 fn call(
2339 &mut self,
2340 request: tonic::Request<super::MsgConsolidateVaults>,
2341 ) -> Self::Future {
2342 let inner = Arc::clone(&self.0);
2343 let fut = async move { (*inner).consolidate_vaults(request).await };
2344 Box::pin(fut)
2345 }
2346 }
2347 let accept_compression_encodings = self.accept_compression_encodings;
2348 let send_compression_encodings = self.send_compression_encodings;
2349 let max_decoding_message_size = self.max_decoding_message_size;
2350 let max_encoding_message_size = self.max_encoding_message_size;
2351 let inner = self.inner.clone();
2352 let fut = async move {
2353 let inner = inner.0;
2354 let method = ConsolidateVaultsSvc(inner);
2355 let codec = tonic::codec::ProstCodec::default();
2356 let mut grpc = tonic::server::Grpc::new(codec)
2357 .apply_compression_config(
2358 accept_compression_encodings,
2359 send_compression_encodings,
2360 )
2361 .apply_max_message_size_config(
2362 max_decoding_message_size,
2363 max_encoding_message_size,
2364 );
2365 let res = grpc.unary(method, req).await;
2366 Ok(res)
2367 };
2368 Box::pin(fut)
2369 }
2370 "/side.btcbridge.Msg/InitiateDKG" => {
2371 #[allow(non_camel_case_types)]
2372 struct InitiateDKGSvc<T: Msg>(pub Arc<T>);
2373 impl<T: Msg> tonic::server::UnaryService<super::MsgInitiateDkg> for InitiateDKGSvc<T> {
2374 type Response = super::MsgInitiateDkgResponse;
2375 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2376 fn call(
2377 &mut self,
2378 request: tonic::Request<super::MsgInitiateDkg>,
2379 ) -> Self::Future {
2380 let inner = Arc::clone(&self.0);
2381 let fut = async move { (*inner).initiate_dkg(request).await };
2382 Box::pin(fut)
2383 }
2384 }
2385 let accept_compression_encodings = self.accept_compression_encodings;
2386 let send_compression_encodings = self.send_compression_encodings;
2387 let max_decoding_message_size = self.max_decoding_message_size;
2388 let max_encoding_message_size = self.max_encoding_message_size;
2389 let inner = self.inner.clone();
2390 let fut = async move {
2391 let inner = inner.0;
2392 let method = InitiateDKGSvc(inner);
2393 let codec = tonic::codec::ProstCodec::default();
2394 let mut grpc = tonic::server::Grpc::new(codec)
2395 .apply_compression_config(
2396 accept_compression_encodings,
2397 send_compression_encodings,
2398 )
2399 .apply_max_message_size_config(
2400 max_decoding_message_size,
2401 max_encoding_message_size,
2402 );
2403 let res = grpc.unary(method, req).await;
2404 Ok(res)
2405 };
2406 Box::pin(fut)
2407 }
2408 "/side.btcbridge.Msg/CompleteDKG" => {
2409 #[allow(non_camel_case_types)]
2410 struct CompleteDKGSvc<T: Msg>(pub Arc<T>);
2411 impl<T: Msg> tonic::server::UnaryService<super::MsgCompleteDkg> for CompleteDKGSvc<T> {
2412 type Response = super::MsgCompleteDkgResponse;
2413 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2414 fn call(
2415 &mut self,
2416 request: tonic::Request<super::MsgCompleteDkg>,
2417 ) -> Self::Future {
2418 let inner = Arc::clone(&self.0);
2419 let fut = async move { (*inner).complete_dkg(request).await };
2420 Box::pin(fut)
2421 }
2422 }
2423 let accept_compression_encodings = self.accept_compression_encodings;
2424 let send_compression_encodings = self.send_compression_encodings;
2425 let max_decoding_message_size = self.max_decoding_message_size;
2426 let max_encoding_message_size = self.max_encoding_message_size;
2427 let inner = self.inner.clone();
2428 let fut = async move {
2429 let inner = inner.0;
2430 let method = CompleteDKGSvc(inner);
2431 let codec = tonic::codec::ProstCodec::default();
2432 let mut grpc = tonic::server::Grpc::new(codec)
2433 .apply_compression_config(
2434 accept_compression_encodings,
2435 send_compression_encodings,
2436 )
2437 .apply_max_message_size_config(
2438 max_decoding_message_size,
2439 max_encoding_message_size,
2440 );
2441 let res = grpc.unary(method, req).await;
2442 Ok(res)
2443 };
2444 Box::pin(fut)
2445 }
2446 "/side.btcbridge.Msg/TransferVault" => {
2447 #[allow(non_camel_case_types)]
2448 struct TransferVaultSvc<T: Msg>(pub Arc<T>);
2449 impl<T: Msg> tonic::server::UnaryService<super::MsgTransferVault> for TransferVaultSvc<T> {
2450 type Response = super::MsgTransferVaultResponse;
2451 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2452 fn call(
2453 &mut self,
2454 request: tonic::Request<super::MsgTransferVault>,
2455 ) -> Self::Future {
2456 let inner = Arc::clone(&self.0);
2457 let fut = async move { (*inner).transfer_vault(request).await };
2458 Box::pin(fut)
2459 }
2460 }
2461 let accept_compression_encodings = self.accept_compression_encodings;
2462 let send_compression_encodings = self.send_compression_encodings;
2463 let max_decoding_message_size = self.max_decoding_message_size;
2464 let max_encoding_message_size = self.max_encoding_message_size;
2465 let inner = self.inner.clone();
2466 let fut = async move {
2467 let inner = inner.0;
2468 let method = TransferVaultSvc(inner);
2469 let codec = tonic::codec::ProstCodec::default();
2470 let mut grpc = tonic::server::Grpc::new(codec)
2471 .apply_compression_config(
2472 accept_compression_encodings,
2473 send_compression_encodings,
2474 )
2475 .apply_max_message_size_config(
2476 max_decoding_message_size,
2477 max_encoding_message_size,
2478 );
2479 let res = grpc.unary(method, req).await;
2480 Ok(res)
2481 };
2482 Box::pin(fut)
2483 }
2484 "/side.btcbridge.Msg/UpdateParams" => {
2485 #[allow(non_camel_case_types)]
2486 struct UpdateParamsSvc<T: Msg>(pub Arc<T>);
2487 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateParams> for UpdateParamsSvc<T> {
2488 type Response = super::MsgUpdateParamsResponse;
2489 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2490 fn call(
2491 &mut self,
2492 request: tonic::Request<super::MsgUpdateParams>,
2493 ) -> Self::Future {
2494 let inner = Arc::clone(&self.0);
2495 let fut = async move { (*inner).update_params(request).await };
2496 Box::pin(fut)
2497 }
2498 }
2499 let accept_compression_encodings = self.accept_compression_encodings;
2500 let send_compression_encodings = self.send_compression_encodings;
2501 let max_decoding_message_size = self.max_decoding_message_size;
2502 let max_encoding_message_size = self.max_encoding_message_size;
2503 let inner = self.inner.clone();
2504 let fut = async move {
2505 let inner = inner.0;
2506 let method = UpdateParamsSvc(inner);
2507 let codec = tonic::codec::ProstCodec::default();
2508 let mut grpc = tonic::server::Grpc::new(codec)
2509 .apply_compression_config(
2510 accept_compression_encodings,
2511 send_compression_encodings,
2512 )
2513 .apply_max_message_size_config(
2514 max_decoding_message_size,
2515 max_encoding_message_size,
2516 );
2517 let res = grpc.unary(method, req).await;
2518 Ok(res)
2519 };
2520 Box::pin(fut)
2521 }
2522 _ => Box::pin(async move {
2523 Ok(http::Response::builder()
2524 .status(200)
2525 .header("grpc-status", "12")
2526 .header("content-type", "application/grpc")
2527 .body(empty_body())
2528 .unwrap())
2529 }),
2530 }
2531 }
2532 }
2533 impl<T: Msg> Clone for MsgServer<T> {
2534 fn clone(&self) -> Self {
2535 let inner = self.inner.clone();
2536 Self {
2537 inner,
2538 accept_compression_encodings: self.accept_compression_encodings,
2539 send_compression_encodings: self.send_compression_encodings,
2540 max_decoding_message_size: self.max_decoding_message_size,
2541 max_encoding_message_size: self.max_encoding_message_size,
2542 }
2543 }
2544 }
2545 impl<T: Msg> Clone for _Inner<T> {
2546 fn clone(&self) -> Self {
2547 Self(Arc::clone(&self.0))
2548 }
2549 }
2550 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
2551 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2552 write!(f, "{:?}", self.0)
2553 }
2554 }
2555 impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
2556 const NAME: &'static str = "side.btcbridge.Msg";
2557 }
2558}