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_fee_rate(
107 &mut self,
108 request: impl tonic::IntoRequest<super::QueryFeeRateRequest>,
109 ) -> core::result::Result<tonic::Response<super::QueryFeeRateResponse>, 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/QueryFeeRate");
119 let mut req = request.into_request();
120 req.extensions_mut()
121 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryFeeRate"));
122 self.inner.unary(req, path, codec).await
123 }
124 pub async fn query_withdrawal_network_fee(
125 &mut self,
126 request: impl tonic::IntoRequest<super::QueryWithdrawalNetworkFeeRequest>,
127 ) -> core::result::Result<
128 tonic::Response<super::QueryWithdrawalNetworkFeeResponse>,
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/QueryWithdrawalNetworkFee",
140 );
141 let mut req = request.into_request();
142 req.extensions_mut().insert(GrpcMethod::new(
143 "side.btcbridge.Query",
144 "QueryWithdrawalNetworkFee",
145 ));
146 self.inner.unary(req, path, codec).await
147 }
148 pub async fn query_withdraw_requests_by_address(
149 &mut self,
150 request: impl tonic::IntoRequest<super::QueryWithdrawRequestsByAddressRequest>,
151 ) -> core::result::Result<
152 tonic::Response<super::QueryWithdrawRequestsByAddressResponse>,
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/QueryWithdrawRequestsByAddress",
164 );
165 let mut req = request.into_request();
166 req.extensions_mut().insert(GrpcMethod::new(
167 "side.btcbridge.Query",
168 "QueryWithdrawRequestsByAddress",
169 ));
170 self.inner.unary(req, path, codec).await
171 }
172 pub async fn query_withdraw_requests_by_tx_hash(
173 &mut self,
174 request: impl tonic::IntoRequest<super::QueryWithdrawRequestsByTxHashRequest>,
175 ) -> core::result::Result<
176 tonic::Response<super::QueryWithdrawRequestsByTxHashResponse>,
177 tonic::Status,
178 > {
179 self.inner.ready().await.map_err(|e| {
180 tonic::Status::new(
181 tonic::Code::Unknown,
182 alloc::format!("Service was not ready: {}", e.into()),
183 )
184 })?;
185 let codec = tonic::codec::ProstCodec::default();
186 let path = http::uri::PathAndQuery::from_static(
187 "/side.btcbridge.Query/QueryWithdrawRequestsByTxHash",
188 );
189 let mut req = request.into_request();
190 req.extensions_mut().insert(GrpcMethod::new(
191 "side.btcbridge.Query",
192 "QueryWithdrawRequestsByTxHash",
193 ));
194 self.inner.unary(req, path, codec).await
195 }
196 pub async fn query_pending_btc_withdraw_requests(
197 &mut self,
198 request: impl tonic::IntoRequest<super::QueryPendingBtcWithdrawRequestsRequest>,
199 ) -> core::result::Result<
200 tonic::Response<super::QueryPendingBtcWithdrawRequestsResponse>,
201 tonic::Status,
202 > {
203 self.inner.ready().await.map_err(|e| {
204 tonic::Status::new(
205 tonic::Code::Unknown,
206 alloc::format!("Service was not ready: {}", e.into()),
207 )
208 })?;
209 let codec = tonic::codec::ProstCodec::default();
210 let path = http::uri::PathAndQuery::from_static(
211 "/side.btcbridge.Query/QueryPendingBtcWithdrawRequests",
212 );
213 let mut req = request.into_request();
214 req.extensions_mut().insert(GrpcMethod::new(
215 "side.btcbridge.Query",
216 "QueryPendingBtcWithdrawRequests",
217 ));
218 self.inner.unary(req, path, codec).await
219 }
220 pub async fn query_signing_request(
221 &mut self,
222 request: impl tonic::IntoRequest<super::QuerySigningRequestRequest>,
223 ) -> core::result::Result<tonic::Response<super::QuerySigningRequestResponse>, tonic::Status>
224 {
225 self.inner.ready().await.map_err(|e| {
226 tonic::Status::new(
227 tonic::Code::Unknown,
228 alloc::format!("Service was not ready: {}", e.into()),
229 )
230 })?;
231 let codec = tonic::codec::ProstCodec::default();
232 let path =
233 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QuerySigningRequest");
234 let mut req = request.into_request();
235 req.extensions_mut().insert(GrpcMethod::new(
236 "side.btcbridge.Query",
237 "QuerySigningRequest",
238 ));
239 self.inner.unary(req, path, codec).await
240 }
241 pub async fn query_signing_requests(
242 &mut self,
243 request: impl tonic::IntoRequest<super::QuerySigningRequestsRequest>,
244 ) -> core::result::Result<tonic::Response<super::QuerySigningRequestsResponse>, tonic::Status>
245 {
246 self.inner.ready().await.map_err(|e| {
247 tonic::Status::new(
248 tonic::Code::Unknown,
249 alloc::format!("Service was not ready: {}", e.into()),
250 )
251 })?;
252 let codec = tonic::codec::ProstCodec::default();
253 let path =
254 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QuerySigningRequests");
255 let mut req = request.into_request();
256 req.extensions_mut().insert(GrpcMethod::new(
257 "side.btcbridge.Query",
258 "QuerySigningRequests",
259 ));
260 self.inner.unary(req, path, codec).await
261 }
262 pub async fn query_signing_requests_by_address(
263 &mut self,
264 request: impl tonic::IntoRequest<super::QuerySigningRequestsByAddressRequest>,
265 ) -> core::result::Result<
266 tonic::Response<super::QuerySigningRequestsByAddressResponse>,
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/QuerySigningRequestsByAddress",
278 );
279 let mut req = request.into_request();
280 req.extensions_mut().insert(GrpcMethod::new(
281 "side.btcbridge.Query",
282 "QuerySigningRequestsByAddress",
283 ));
284 self.inner.unary(req, path, codec).await
285 }
286 pub async fn query_signing_request_by_tx_hash(
287 &mut self,
288 request: impl tonic::IntoRequest<super::QuerySigningRequestByTxHashRequest>,
289 ) -> core::result::Result<
290 tonic::Response<super::QuerySigningRequestByTxHashResponse>,
291 tonic::Status,
292 > {
293 self.inner.ready().await.map_err(|e| {
294 tonic::Status::new(
295 tonic::Code::Unknown,
296 alloc::format!("Service was not ready: {}", e.into()),
297 )
298 })?;
299 let codec = tonic::codec::ProstCodec::default();
300 let path = http::uri::PathAndQuery::from_static(
301 "/side.btcbridge.Query/QuerySigningRequestByTxHash",
302 );
303 let mut req = request.into_request();
304 req.extensions_mut().insert(GrpcMethod::new(
305 "side.btcbridge.Query",
306 "QuerySigningRequestByTxHash",
307 ));
308 self.inner.unary(req, path, codec).await
309 }
310 pub async fn query_pending_signing_requests(
311 &mut self,
312 request: impl tonic::IntoRequest<super::QueryPendingSigningRequestsRequest>,
313 ) -> core::result::Result<
314 tonic::Response<super::QueryPendingSigningRequestsResponse>,
315 tonic::Status,
316 > {
317 self.inner.ready().await.map_err(|e| {
318 tonic::Status::new(
319 tonic::Code::Unknown,
320 alloc::format!("Service was not ready: {}", e.into()),
321 )
322 })?;
323 let codec = tonic::codec::ProstCodec::default();
324 let path = http::uri::PathAndQuery::from_static(
325 "/side.btcbridge.Query/QueryPendingSigningRequests",
326 );
327 let mut req = request.into_request();
328 req.extensions_mut().insert(GrpcMethod::new(
329 "side.btcbridge.Query",
330 "QueryPendingSigningRequests",
331 ));
332 self.inner.unary(req, path, codec).await
333 }
334 pub async fn query_utx_os(
335 &mut self,
336 request: impl tonic::IntoRequest<super::QueryUtxOsRequest>,
337 ) -> core::result::Result<tonic::Response<super::QueryUtxOsResponse>, tonic::Status>
338 {
339 self.inner.ready().await.map_err(|e| {
340 tonic::Status::new(
341 tonic::Code::Unknown,
342 alloc::format!("Service was not ready: {}", e.into()),
343 )
344 })?;
345 let codec = tonic::codec::ProstCodec::default();
346 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryUTXOs");
347 let mut req = request.into_request();
348 req.extensions_mut()
349 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryUTXOs"));
350 self.inner.unary(req, path, codec).await
351 }
352 pub async fn query_utx_os_by_address(
353 &mut self,
354 request: impl tonic::IntoRequest<super::QueryUtxOsByAddressRequest>,
355 ) -> core::result::Result<tonic::Response<super::QueryUtxOsByAddressResponse>, tonic::Status>
356 {
357 self.inner.ready().await.map_err(|e| {
358 tonic::Status::new(
359 tonic::Code::Unknown,
360 alloc::format!("Service was not ready: {}", e.into()),
361 )
362 })?;
363 let codec = tonic::codec::ProstCodec::default();
364 let path =
365 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryUTXOsByAddress");
366 let mut req = request.into_request();
367 req.extensions_mut().insert(GrpcMethod::new(
368 "side.btcbridge.Query",
369 "QueryUTXOsByAddress",
370 ));
371 self.inner.unary(req, path, codec).await
372 }
373 pub async fn query_utxo_count_and_balances_by_address(
374 &mut self,
375 request: impl tonic::IntoRequest<super::QueryUtxoCountAndBalancesByAddressRequest>,
376 ) -> core::result::Result<
377 tonic::Response<super::QueryUtxoCountAndBalancesByAddressResponse>,
378 tonic::Status,
379 > {
380 self.inner.ready().await.map_err(|e| {
381 tonic::Status::new(
382 tonic::Code::Unknown,
383 alloc::format!("Service was not ready: {}", e.into()),
384 )
385 })?;
386 let codec = tonic::codec::ProstCodec::default();
387 let path = http::uri::PathAndQuery::from_static(
388 "/side.btcbridge.Query/QueryUTXOCountAndBalancesByAddress",
389 );
390 let mut req = request.into_request();
391 req.extensions_mut().insert(GrpcMethod::new(
392 "side.btcbridge.Query",
393 "QueryUTXOCountAndBalancesByAddress",
394 ));
395 self.inner.unary(req, path, codec).await
396 }
397 pub async fn query_dkg_request(
398 &mut self,
399 request: impl tonic::IntoRequest<super::QueryDkgRequestRequest>,
400 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestResponse>, tonic::Status>
401 {
402 self.inner.ready().await.map_err(|e| {
403 tonic::Status::new(
404 tonic::Code::Unknown,
405 alloc::format!("Service was not ready: {}", e.into()),
406 )
407 })?;
408 let codec = tonic::codec::ProstCodec::default();
409 let path =
410 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryDKGRequest");
411 let mut req = request.into_request();
412 req.extensions_mut()
413 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryDKGRequest"));
414 self.inner.unary(req, path, codec).await
415 }
416 pub async fn query_dkg_requests(
417 &mut self,
418 request: impl tonic::IntoRequest<super::QueryDkgRequestsRequest>,
419 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestsResponse>, tonic::Status>
420 {
421 self.inner.ready().await.map_err(|e| {
422 tonic::Status::new(
423 tonic::Code::Unknown,
424 alloc::format!("Service was not ready: {}", e.into()),
425 )
426 })?;
427 let codec = tonic::codec::ProstCodec::default();
428 let path =
429 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryDKGRequests");
430 let mut req = request.into_request();
431 req.extensions_mut()
432 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryDKGRequests"));
433 self.inner.unary(req, path, codec).await
434 }
435 pub async fn query_all_dkg_requests(
436 &mut self,
437 request: impl tonic::IntoRequest<super::QueryAllDkgRequestsRequest>,
438 ) -> core::result::Result<tonic::Response<super::QueryAllDkgRequestsResponse>, tonic::Status>
439 {
440 self.inner.ready().await.map_err(|e| {
441 tonic::Status::new(
442 tonic::Code::Unknown,
443 alloc::format!("Service was not ready: {}", e.into()),
444 )
445 })?;
446 let codec = tonic::codec::ProstCodec::default();
447 let path =
448 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryAllDKGRequests");
449 let mut req = request.into_request();
450 req.extensions_mut().insert(GrpcMethod::new(
451 "side.btcbridge.Query",
452 "QueryAllDKGRequests",
453 ));
454 self.inner.unary(req, path, codec).await
455 }
456 pub async fn query_dkg_completion_requests(
457 &mut self,
458 request: impl tonic::IntoRequest<super::QueryDkgCompletionRequestsRequest>,
459 ) -> core::result::Result<
460 tonic::Response<super::QueryDkgCompletionRequestsResponse>,
461 tonic::Status,
462 > {
463 self.inner.ready().await.map_err(|e| {
464 tonic::Status::new(
465 tonic::Code::Unknown,
466 alloc::format!("Service was not ready: {}", e.into()),
467 )
468 })?;
469 let codec = tonic::codec::ProstCodec::default();
470 let path = http::uri::PathAndQuery::from_static(
471 "/side.btcbridge.Query/QueryDKGCompletionRequests",
472 );
473 let mut req = request.into_request();
474 req.extensions_mut().insert(GrpcMethod::new(
475 "side.btcbridge.Query",
476 "QueryDKGCompletionRequests",
477 ));
478 self.inner.unary(req, path, codec).await
479 }
480 pub async fn query_refreshing_request(
481 &mut self,
482 request: impl tonic::IntoRequest<super::QueryRefreshingRequestRequest>,
483 ) -> core::result::Result<
484 tonic::Response<super::QueryRefreshingRequestResponse>,
485 tonic::Status,
486 > {
487 self.inner.ready().await.map_err(|e| {
488 tonic::Status::new(
489 tonic::Code::Unknown,
490 alloc::format!("Service was not ready: {}", e.into()),
491 )
492 })?;
493 let codec = tonic::codec::ProstCodec::default();
494 let path = http::uri::PathAndQuery::from_static(
495 "/side.btcbridge.Query/QueryRefreshingRequest",
496 );
497 let mut req = request.into_request();
498 req.extensions_mut().insert(GrpcMethod::new(
499 "side.btcbridge.Query",
500 "QueryRefreshingRequest",
501 ));
502 self.inner.unary(req, path, codec).await
503 }
504 pub async fn query_refreshing_requests(
505 &mut self,
506 request: impl tonic::IntoRequest<super::QueryRefreshingRequestsRequest>,
507 ) -> core::result::Result<
508 tonic::Response<super::QueryRefreshingRequestsResponse>,
509 tonic::Status,
510 > {
511 self.inner.ready().await.map_err(|e| {
512 tonic::Status::new(
513 tonic::Code::Unknown,
514 alloc::format!("Service was not ready: {}", e.into()),
515 )
516 })?;
517 let codec = tonic::codec::ProstCodec::default();
518 let path = http::uri::PathAndQuery::from_static(
519 "/side.btcbridge.Query/QueryRefreshingRequests",
520 );
521 let mut req = request.into_request();
522 req.extensions_mut().insert(GrpcMethod::new(
523 "side.btcbridge.Query",
524 "QueryRefreshingRequests",
525 ));
526 self.inner.unary(req, path, codec).await
527 }
528 pub async fn query_refreshing_completions(
529 &mut self,
530 request: impl tonic::IntoRequest<super::QueryRefreshingCompletionsRequest>,
531 ) -> core::result::Result<
532 tonic::Response<super::QueryRefreshingCompletionsResponse>,
533 tonic::Status,
534 > {
535 self.inner.ready().await.map_err(|e| {
536 tonic::Status::new(
537 tonic::Code::Unknown,
538 alloc::format!("Service was not ready: {}", e.into()),
539 )
540 })?;
541 let codec = tonic::codec::ProstCodec::default();
542 let path = http::uri::PathAndQuery::from_static(
543 "/side.btcbridge.Query/QueryRefreshingCompletions",
544 );
545 let mut req = request.into_request();
546 req.extensions_mut().insert(GrpcMethod::new(
547 "side.btcbridge.Query",
548 "QueryRefreshingCompletions",
549 ));
550 self.inner.unary(req, path, codec).await
551 }
552 pub async fn query_ibc_deposit_script(
553 &mut self,
554 request: impl tonic::IntoRequest<super::QueryIbcDepositScriptRequest>,
555 ) -> core::result::Result<
556 tonic::Response<super::QueryIbcDepositScriptResponse>,
557 tonic::Status,
558 > {
559 self.inner.ready().await.map_err(|e| {
560 tonic::Status::new(
561 tonic::Code::Unknown,
562 alloc::format!("Service was not ready: {}", e.into()),
563 )
564 })?;
565 let codec = tonic::codec::ProstCodec::default();
566 let path =
567 http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryIBCDepositScript");
568 let mut req = request.into_request();
569 req.extensions_mut().insert(GrpcMethod::new(
570 "side.btcbridge.Query",
571 "QueryIBCDepositScript",
572 ));
573 self.inner.unary(req, path, codec).await
574 }
575 pub async fn query_rate_limit(
576 &mut self,
577 request: impl tonic::IntoRequest<super::QueryRateLimitRequest>,
578 ) -> core::result::Result<tonic::Response<super::QueryRateLimitResponse>, tonic::Status>
579 {
580 self.inner.ready().await.map_err(|e| {
581 tonic::Status::new(
582 tonic::Code::Unknown,
583 alloc::format!("Service was not ready: {}", e.into()),
584 )
585 })?;
586 let codec = tonic::codec::ProstCodec::default();
587 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Query/QueryRateLimit");
588 let mut req = request.into_request();
589 req.extensions_mut()
590 .insert(GrpcMethod::new("side.btcbridge.Query", "QueryRateLimit"));
591 self.inner.unary(req, path, codec).await
592 }
593 pub async fn query_rate_limit_by_address(
594 &mut self,
595 request: impl tonic::IntoRequest<super::QueryRateLimitByAddressRequest>,
596 ) -> core::result::Result<
597 tonic::Response<super::QueryRateLimitByAddressResponse>,
598 tonic::Status,
599 > {
600 self.inner.ready().await.map_err(|e| {
601 tonic::Status::new(
602 tonic::Code::Unknown,
603 alloc::format!("Service was not ready: {}", e.into()),
604 )
605 })?;
606 let codec = tonic::codec::ProstCodec::default();
607 let path = http::uri::PathAndQuery::from_static(
608 "/side.btcbridge.Query/QueryRateLimitByAddress",
609 );
610 let mut req = request.into_request();
611 req.extensions_mut().insert(GrpcMethod::new(
612 "side.btcbridge.Query",
613 "QueryRateLimitByAddress",
614 ));
615 self.inner.unary(req, path, codec).await
616 }
617 }
618}
619#[cfg(feature = "grpc")]
621pub mod query_server {
622 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
623 use tonic::codegen::*;
624 #[async_trait]
626 pub trait Query: Send + Sync + 'static {
627 async fn query_params(
628 &self,
629 request: tonic::Request<super::QueryParamsRequest>,
630 ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
631 async fn query_fee_rate(
632 &self,
633 request: tonic::Request<super::QueryFeeRateRequest>,
634 ) -> core::result::Result<tonic::Response<super::QueryFeeRateResponse>, tonic::Status>;
635 async fn query_withdrawal_network_fee(
636 &self,
637 request: tonic::Request<super::QueryWithdrawalNetworkFeeRequest>,
638 ) -> core::result::Result<
639 tonic::Response<super::QueryWithdrawalNetworkFeeResponse>,
640 tonic::Status,
641 >;
642 async fn query_withdraw_requests_by_address(
643 &self,
644 request: tonic::Request<super::QueryWithdrawRequestsByAddressRequest>,
645 ) -> core::result::Result<
646 tonic::Response<super::QueryWithdrawRequestsByAddressResponse>,
647 tonic::Status,
648 >;
649 async fn query_withdraw_requests_by_tx_hash(
650 &self,
651 request: tonic::Request<super::QueryWithdrawRequestsByTxHashRequest>,
652 ) -> core::result::Result<
653 tonic::Response<super::QueryWithdrawRequestsByTxHashResponse>,
654 tonic::Status,
655 >;
656 async fn query_pending_btc_withdraw_requests(
657 &self,
658 request: tonic::Request<super::QueryPendingBtcWithdrawRequestsRequest>,
659 ) -> core::result::Result<
660 tonic::Response<super::QueryPendingBtcWithdrawRequestsResponse>,
661 tonic::Status,
662 >;
663 async fn query_signing_request(
664 &self,
665 request: tonic::Request<super::QuerySigningRequestRequest>,
666 ) -> core::result::Result<tonic::Response<super::QuerySigningRequestResponse>, tonic::Status>;
667 async fn query_signing_requests(
668 &self,
669 request: tonic::Request<super::QuerySigningRequestsRequest>,
670 ) -> core::result::Result<tonic::Response<super::QuerySigningRequestsResponse>, tonic::Status>;
671 async fn query_signing_requests_by_address(
672 &self,
673 request: tonic::Request<super::QuerySigningRequestsByAddressRequest>,
674 ) -> core::result::Result<
675 tonic::Response<super::QuerySigningRequestsByAddressResponse>,
676 tonic::Status,
677 >;
678 async fn query_signing_request_by_tx_hash(
679 &self,
680 request: tonic::Request<super::QuerySigningRequestByTxHashRequest>,
681 ) -> core::result::Result<
682 tonic::Response<super::QuerySigningRequestByTxHashResponse>,
683 tonic::Status,
684 >;
685 async fn query_pending_signing_requests(
686 &self,
687 request: tonic::Request<super::QueryPendingSigningRequestsRequest>,
688 ) -> core::result::Result<
689 tonic::Response<super::QueryPendingSigningRequestsResponse>,
690 tonic::Status,
691 >;
692 async fn query_utx_os(
693 &self,
694 request: tonic::Request<super::QueryUtxOsRequest>,
695 ) -> core::result::Result<tonic::Response<super::QueryUtxOsResponse>, tonic::Status>;
696 async fn query_utx_os_by_address(
697 &self,
698 request: tonic::Request<super::QueryUtxOsByAddressRequest>,
699 ) -> core::result::Result<tonic::Response<super::QueryUtxOsByAddressResponse>, tonic::Status>;
700 async fn query_utxo_count_and_balances_by_address(
701 &self,
702 request: tonic::Request<super::QueryUtxoCountAndBalancesByAddressRequest>,
703 ) -> core::result::Result<
704 tonic::Response<super::QueryUtxoCountAndBalancesByAddressResponse>,
705 tonic::Status,
706 >;
707 async fn query_dkg_request(
708 &self,
709 request: tonic::Request<super::QueryDkgRequestRequest>,
710 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestResponse>, tonic::Status>;
711 async fn query_dkg_requests(
712 &self,
713 request: tonic::Request<super::QueryDkgRequestsRequest>,
714 ) -> core::result::Result<tonic::Response<super::QueryDkgRequestsResponse>, tonic::Status>;
715 async fn query_all_dkg_requests(
716 &self,
717 request: tonic::Request<super::QueryAllDkgRequestsRequest>,
718 ) -> core::result::Result<tonic::Response<super::QueryAllDkgRequestsResponse>, tonic::Status>;
719 async fn query_dkg_completion_requests(
720 &self,
721 request: tonic::Request<super::QueryDkgCompletionRequestsRequest>,
722 ) -> core::result::Result<
723 tonic::Response<super::QueryDkgCompletionRequestsResponse>,
724 tonic::Status,
725 >;
726 async fn query_refreshing_request(
727 &self,
728 request: tonic::Request<super::QueryRefreshingRequestRequest>,
729 ) -> core::result::Result<
730 tonic::Response<super::QueryRefreshingRequestResponse>,
731 tonic::Status,
732 >;
733 async fn query_refreshing_requests(
734 &self,
735 request: tonic::Request<super::QueryRefreshingRequestsRequest>,
736 ) -> core::result::Result<
737 tonic::Response<super::QueryRefreshingRequestsResponse>,
738 tonic::Status,
739 >;
740 async fn query_refreshing_completions(
741 &self,
742 request: tonic::Request<super::QueryRefreshingCompletionsRequest>,
743 ) -> core::result::Result<
744 tonic::Response<super::QueryRefreshingCompletionsResponse>,
745 tonic::Status,
746 >;
747 async fn query_ibc_deposit_script(
748 &self,
749 request: tonic::Request<super::QueryIbcDepositScriptRequest>,
750 ) -> core::result::Result<
751 tonic::Response<super::QueryIbcDepositScriptResponse>,
752 tonic::Status,
753 >;
754 async fn query_rate_limit(
755 &self,
756 request: tonic::Request<super::QueryRateLimitRequest>,
757 ) -> core::result::Result<tonic::Response<super::QueryRateLimitResponse>, tonic::Status>;
758 async fn query_rate_limit_by_address(
759 &self,
760 request: tonic::Request<super::QueryRateLimitByAddressRequest>,
761 ) -> core::result::Result<
762 tonic::Response<super::QueryRateLimitByAddressResponse>,
763 tonic::Status,
764 >;
765 }
766 #[derive(Debug)]
767 pub struct QueryServer<T: Query> {
768 inner: _Inner<T>,
769 accept_compression_encodings: EnabledCompressionEncodings,
770 send_compression_encodings: EnabledCompressionEncodings,
771 max_decoding_message_size: Option<usize>,
772 max_encoding_message_size: Option<usize>,
773 }
774 struct _Inner<T>(Arc<T>);
775 impl<T: Query> QueryServer<T> {
776 pub fn new(inner: T) -> Self {
777 Self::from_arc(Arc::new(inner))
778 }
779 pub fn from_arc(inner: Arc<T>) -> Self {
780 let inner = _Inner(inner);
781 Self {
782 inner,
783 accept_compression_encodings: Default::default(),
784 send_compression_encodings: Default::default(),
785 max_decoding_message_size: None,
786 max_encoding_message_size: None,
787 }
788 }
789 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
790 where
791 F: tonic::service::Interceptor,
792 {
793 InterceptedService::new(Self::new(inner), interceptor)
794 }
795 #[must_use]
797 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
798 self.accept_compression_encodings.enable(encoding);
799 self
800 }
801 #[must_use]
803 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
804 self.send_compression_encodings.enable(encoding);
805 self
806 }
807 #[must_use]
811 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
812 self.max_decoding_message_size = Some(limit);
813 self
814 }
815 #[must_use]
819 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
820 self.max_encoding_message_size = Some(limit);
821 self
822 }
823 }
824 impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
825 where
826 T: Query,
827 B: Body + Send + 'static,
828 B::Error: Into<StdError> + Send + 'static,
829 {
830 type Response = http::Response<tonic::body::BoxBody>;
831 type Error = std::convert::Infallible;
832 type Future = BoxFuture<Self::Response, Self::Error>;
833 fn poll_ready(
834 &mut self,
835 _cx: &mut Context<'_>,
836 ) -> Poll<core::result::Result<(), Self::Error>> {
837 Poll::Ready(Ok(()))
838 }
839 fn call(&mut self, req: http::Request<B>) -> Self::Future {
840 let inner = self.inner.clone();
841 match req.uri().path() {
842 "/side.btcbridge.Query/QueryParams" => {
843 #[allow(non_camel_case_types)]
844 struct QueryParamsSvc<T: Query>(pub Arc<T>);
845 impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for QueryParamsSvc<T> {
846 type Response = super::QueryParamsResponse;
847 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
848 fn call(
849 &mut self,
850 request: tonic::Request<super::QueryParamsRequest>,
851 ) -> Self::Future {
852 let inner = Arc::clone(&self.0);
853 let fut = async move { (*inner).query_params(request).await };
854 Box::pin(fut)
855 }
856 }
857 let accept_compression_encodings = self.accept_compression_encodings;
858 let send_compression_encodings = self.send_compression_encodings;
859 let max_decoding_message_size = self.max_decoding_message_size;
860 let max_encoding_message_size = self.max_encoding_message_size;
861 let inner = self.inner.clone();
862 let fut = async move {
863 let inner = inner.0;
864 let method = QueryParamsSvc(inner);
865 let codec = tonic::codec::ProstCodec::default();
866 let mut grpc = tonic::server::Grpc::new(codec)
867 .apply_compression_config(
868 accept_compression_encodings,
869 send_compression_encodings,
870 )
871 .apply_max_message_size_config(
872 max_decoding_message_size,
873 max_encoding_message_size,
874 );
875 let res = grpc.unary(method, req).await;
876 Ok(res)
877 };
878 Box::pin(fut)
879 }
880 "/side.btcbridge.Query/QueryFeeRate" => {
881 #[allow(non_camel_case_types)]
882 struct QueryFeeRateSvc<T: Query>(pub Arc<T>);
883 impl<T: Query> tonic::server::UnaryService<super::QueryFeeRateRequest> for QueryFeeRateSvc<T> {
884 type Response = super::QueryFeeRateResponse;
885 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
886 fn call(
887 &mut self,
888 request: tonic::Request<super::QueryFeeRateRequest>,
889 ) -> Self::Future {
890 let inner = Arc::clone(&self.0);
891 let fut = async move { (*inner).query_fee_rate(request).await };
892 Box::pin(fut)
893 }
894 }
895 let accept_compression_encodings = self.accept_compression_encodings;
896 let send_compression_encodings = self.send_compression_encodings;
897 let max_decoding_message_size = self.max_decoding_message_size;
898 let max_encoding_message_size = self.max_encoding_message_size;
899 let inner = self.inner.clone();
900 let fut = async move {
901 let inner = inner.0;
902 let method = QueryFeeRateSvc(inner);
903 let codec = tonic::codec::ProstCodec::default();
904 let mut grpc = tonic::server::Grpc::new(codec)
905 .apply_compression_config(
906 accept_compression_encodings,
907 send_compression_encodings,
908 )
909 .apply_max_message_size_config(
910 max_decoding_message_size,
911 max_encoding_message_size,
912 );
913 let res = grpc.unary(method, req).await;
914 Ok(res)
915 };
916 Box::pin(fut)
917 }
918 "/side.btcbridge.Query/QueryWithdrawalNetworkFee" => {
919 #[allow(non_camel_case_types)]
920 struct QueryWithdrawalNetworkFeeSvc<T: Query>(pub Arc<T>);
921 impl<T: Query>
922 tonic::server::UnaryService<super::QueryWithdrawalNetworkFeeRequest>
923 for QueryWithdrawalNetworkFeeSvc<T>
924 {
925 type Response = super::QueryWithdrawalNetworkFeeResponse;
926 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
927 fn call(
928 &mut self,
929 request: tonic::Request<super::QueryWithdrawalNetworkFeeRequest>,
930 ) -> Self::Future {
931 let inner = Arc::clone(&self.0);
932 let fut =
933 async move { (*inner).query_withdrawal_network_fee(request).await };
934 Box::pin(fut)
935 }
936 }
937 let accept_compression_encodings = self.accept_compression_encodings;
938 let send_compression_encodings = self.send_compression_encodings;
939 let max_decoding_message_size = self.max_decoding_message_size;
940 let max_encoding_message_size = self.max_encoding_message_size;
941 let inner = self.inner.clone();
942 let fut = async move {
943 let inner = inner.0;
944 let method = QueryWithdrawalNetworkFeeSvc(inner);
945 let codec = tonic::codec::ProstCodec::default();
946 let mut grpc = tonic::server::Grpc::new(codec)
947 .apply_compression_config(
948 accept_compression_encodings,
949 send_compression_encodings,
950 )
951 .apply_max_message_size_config(
952 max_decoding_message_size,
953 max_encoding_message_size,
954 );
955 let res = grpc.unary(method, req).await;
956 Ok(res)
957 };
958 Box::pin(fut)
959 }
960 "/side.btcbridge.Query/QueryWithdrawRequestsByAddress" => {
961 #[allow(non_camel_case_types)]
962 struct QueryWithdrawRequestsByAddressSvc<T: Query>(pub Arc<T>);
963 impl<T: Query>
964 tonic::server::UnaryService<super::QueryWithdrawRequestsByAddressRequest>
965 for QueryWithdrawRequestsByAddressSvc<T>
966 {
967 type Response = super::QueryWithdrawRequestsByAddressResponse;
968 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
969 fn call(
970 &mut self,
971 request: tonic::Request<super::QueryWithdrawRequestsByAddressRequest>,
972 ) -> Self::Future {
973 let inner = Arc::clone(&self.0);
974 let fut = async move {
975 (*inner).query_withdraw_requests_by_address(request).await
976 };
977 Box::pin(fut)
978 }
979 }
980 let accept_compression_encodings = self.accept_compression_encodings;
981 let send_compression_encodings = self.send_compression_encodings;
982 let max_decoding_message_size = self.max_decoding_message_size;
983 let max_encoding_message_size = self.max_encoding_message_size;
984 let inner = self.inner.clone();
985 let fut = async move {
986 let inner = inner.0;
987 let method = QueryWithdrawRequestsByAddressSvc(inner);
988 let codec = tonic::codec::ProstCodec::default();
989 let mut grpc = tonic::server::Grpc::new(codec)
990 .apply_compression_config(
991 accept_compression_encodings,
992 send_compression_encodings,
993 )
994 .apply_max_message_size_config(
995 max_decoding_message_size,
996 max_encoding_message_size,
997 );
998 let res = grpc.unary(method, req).await;
999 Ok(res)
1000 };
1001 Box::pin(fut)
1002 }
1003 "/side.btcbridge.Query/QueryWithdrawRequestsByTxHash" => {
1004 #[allow(non_camel_case_types)]
1005 struct QueryWithdrawRequestsByTxHashSvc<T: Query>(pub Arc<T>);
1006 impl<T: Query>
1007 tonic::server::UnaryService<super::QueryWithdrawRequestsByTxHashRequest>
1008 for QueryWithdrawRequestsByTxHashSvc<T>
1009 {
1010 type Response = super::QueryWithdrawRequestsByTxHashResponse;
1011 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1012 fn call(
1013 &mut self,
1014 request: tonic::Request<super::QueryWithdrawRequestsByTxHashRequest>,
1015 ) -> Self::Future {
1016 let inner = Arc::clone(&self.0);
1017 let fut = async move {
1018 (*inner).query_withdraw_requests_by_tx_hash(request).await
1019 };
1020 Box::pin(fut)
1021 }
1022 }
1023 let accept_compression_encodings = self.accept_compression_encodings;
1024 let send_compression_encodings = self.send_compression_encodings;
1025 let max_decoding_message_size = self.max_decoding_message_size;
1026 let max_encoding_message_size = self.max_encoding_message_size;
1027 let inner = self.inner.clone();
1028 let fut = async move {
1029 let inner = inner.0;
1030 let method = QueryWithdrawRequestsByTxHashSvc(inner);
1031 let codec = tonic::codec::ProstCodec::default();
1032 let mut grpc = tonic::server::Grpc::new(codec)
1033 .apply_compression_config(
1034 accept_compression_encodings,
1035 send_compression_encodings,
1036 )
1037 .apply_max_message_size_config(
1038 max_decoding_message_size,
1039 max_encoding_message_size,
1040 );
1041 let res = grpc.unary(method, req).await;
1042 Ok(res)
1043 };
1044 Box::pin(fut)
1045 }
1046 "/side.btcbridge.Query/QueryPendingBtcWithdrawRequests" => {
1047 #[allow(non_camel_case_types)]
1048 struct QueryPendingBtcWithdrawRequestsSvc<T: Query>(pub Arc<T>);
1049 impl<T: Query>
1050 tonic::server::UnaryService<super::QueryPendingBtcWithdrawRequestsRequest>
1051 for QueryPendingBtcWithdrawRequestsSvc<T>
1052 {
1053 type Response = super::QueryPendingBtcWithdrawRequestsResponse;
1054 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1055 fn call(
1056 &mut self,
1057 request: tonic::Request<super::QueryPendingBtcWithdrawRequestsRequest>,
1058 ) -> Self::Future {
1059 let inner = Arc::clone(&self.0);
1060 let fut = async move {
1061 (*inner).query_pending_btc_withdraw_requests(request).await
1062 };
1063 Box::pin(fut)
1064 }
1065 }
1066 let accept_compression_encodings = self.accept_compression_encodings;
1067 let send_compression_encodings = self.send_compression_encodings;
1068 let max_decoding_message_size = self.max_decoding_message_size;
1069 let max_encoding_message_size = self.max_encoding_message_size;
1070 let inner = self.inner.clone();
1071 let fut = async move {
1072 let inner = inner.0;
1073 let method = QueryPendingBtcWithdrawRequestsSvc(inner);
1074 let codec = tonic::codec::ProstCodec::default();
1075 let mut grpc = tonic::server::Grpc::new(codec)
1076 .apply_compression_config(
1077 accept_compression_encodings,
1078 send_compression_encodings,
1079 )
1080 .apply_max_message_size_config(
1081 max_decoding_message_size,
1082 max_encoding_message_size,
1083 );
1084 let res = grpc.unary(method, req).await;
1085 Ok(res)
1086 };
1087 Box::pin(fut)
1088 }
1089 "/side.btcbridge.Query/QuerySigningRequest" => {
1090 #[allow(non_camel_case_types)]
1091 struct QuerySigningRequestSvc<T: Query>(pub Arc<T>);
1092 impl<T: Query> tonic::server::UnaryService<super::QuerySigningRequestRequest>
1093 for QuerySigningRequestSvc<T>
1094 {
1095 type Response = super::QuerySigningRequestResponse;
1096 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1097 fn call(
1098 &mut self,
1099 request: tonic::Request<super::QuerySigningRequestRequest>,
1100 ) -> Self::Future {
1101 let inner = Arc::clone(&self.0);
1102 let fut = async move { (*inner).query_signing_request(request).await };
1103 Box::pin(fut)
1104 }
1105 }
1106 let accept_compression_encodings = self.accept_compression_encodings;
1107 let send_compression_encodings = self.send_compression_encodings;
1108 let max_decoding_message_size = self.max_decoding_message_size;
1109 let max_encoding_message_size = self.max_encoding_message_size;
1110 let inner = self.inner.clone();
1111 let fut = async move {
1112 let inner = inner.0;
1113 let method = QuerySigningRequestSvc(inner);
1114 let codec = tonic::codec::ProstCodec::default();
1115 let mut grpc = tonic::server::Grpc::new(codec)
1116 .apply_compression_config(
1117 accept_compression_encodings,
1118 send_compression_encodings,
1119 )
1120 .apply_max_message_size_config(
1121 max_decoding_message_size,
1122 max_encoding_message_size,
1123 );
1124 let res = grpc.unary(method, req).await;
1125 Ok(res)
1126 };
1127 Box::pin(fut)
1128 }
1129 "/side.btcbridge.Query/QuerySigningRequests" => {
1130 #[allow(non_camel_case_types)]
1131 struct QuerySigningRequestsSvc<T: Query>(pub Arc<T>);
1132 impl<T: Query> tonic::server::UnaryService<super::QuerySigningRequestsRequest>
1133 for QuerySigningRequestsSvc<T>
1134 {
1135 type Response = super::QuerySigningRequestsResponse;
1136 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1137 fn call(
1138 &mut self,
1139 request: tonic::Request<super::QuerySigningRequestsRequest>,
1140 ) -> Self::Future {
1141 let inner = Arc::clone(&self.0);
1142 let fut = async move { (*inner).query_signing_requests(request).await };
1143 Box::pin(fut)
1144 }
1145 }
1146 let accept_compression_encodings = self.accept_compression_encodings;
1147 let send_compression_encodings = self.send_compression_encodings;
1148 let max_decoding_message_size = self.max_decoding_message_size;
1149 let max_encoding_message_size = self.max_encoding_message_size;
1150 let inner = self.inner.clone();
1151 let fut = async move {
1152 let inner = inner.0;
1153 let method = QuerySigningRequestsSvc(inner);
1154 let codec = tonic::codec::ProstCodec::default();
1155 let mut grpc = tonic::server::Grpc::new(codec)
1156 .apply_compression_config(
1157 accept_compression_encodings,
1158 send_compression_encodings,
1159 )
1160 .apply_max_message_size_config(
1161 max_decoding_message_size,
1162 max_encoding_message_size,
1163 );
1164 let res = grpc.unary(method, req).await;
1165 Ok(res)
1166 };
1167 Box::pin(fut)
1168 }
1169 "/side.btcbridge.Query/QuerySigningRequestsByAddress" => {
1170 #[allow(non_camel_case_types)]
1171 struct QuerySigningRequestsByAddressSvc<T: Query>(pub Arc<T>);
1172 impl<T: Query>
1173 tonic::server::UnaryService<super::QuerySigningRequestsByAddressRequest>
1174 for QuerySigningRequestsByAddressSvc<T>
1175 {
1176 type Response = super::QuerySigningRequestsByAddressResponse;
1177 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1178 fn call(
1179 &mut self,
1180 request: tonic::Request<super::QuerySigningRequestsByAddressRequest>,
1181 ) -> Self::Future {
1182 let inner = Arc::clone(&self.0);
1183 let fut = async move {
1184 (*inner).query_signing_requests_by_address(request).await
1185 };
1186 Box::pin(fut)
1187 }
1188 }
1189 let accept_compression_encodings = self.accept_compression_encodings;
1190 let send_compression_encodings = self.send_compression_encodings;
1191 let max_decoding_message_size = self.max_decoding_message_size;
1192 let max_encoding_message_size = self.max_encoding_message_size;
1193 let inner = self.inner.clone();
1194 let fut = async move {
1195 let inner = inner.0;
1196 let method = QuerySigningRequestsByAddressSvc(inner);
1197 let codec = tonic::codec::ProstCodec::default();
1198 let mut grpc = tonic::server::Grpc::new(codec)
1199 .apply_compression_config(
1200 accept_compression_encodings,
1201 send_compression_encodings,
1202 )
1203 .apply_max_message_size_config(
1204 max_decoding_message_size,
1205 max_encoding_message_size,
1206 );
1207 let res = grpc.unary(method, req).await;
1208 Ok(res)
1209 };
1210 Box::pin(fut)
1211 }
1212 "/side.btcbridge.Query/QuerySigningRequestByTxHash" => {
1213 #[allow(non_camel_case_types)]
1214 struct QuerySigningRequestByTxHashSvc<T: Query>(pub Arc<T>);
1215 impl<T: Query>
1216 tonic::server::UnaryService<super::QuerySigningRequestByTxHashRequest>
1217 for QuerySigningRequestByTxHashSvc<T>
1218 {
1219 type Response = super::QuerySigningRequestByTxHashResponse;
1220 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1221 fn call(
1222 &mut self,
1223 request: tonic::Request<super::QuerySigningRequestByTxHashRequest>,
1224 ) -> Self::Future {
1225 let inner = Arc::clone(&self.0);
1226 let fut = async move {
1227 (*inner).query_signing_request_by_tx_hash(request).await
1228 };
1229 Box::pin(fut)
1230 }
1231 }
1232 let accept_compression_encodings = self.accept_compression_encodings;
1233 let send_compression_encodings = self.send_compression_encodings;
1234 let max_decoding_message_size = self.max_decoding_message_size;
1235 let max_encoding_message_size = self.max_encoding_message_size;
1236 let inner = self.inner.clone();
1237 let fut = async move {
1238 let inner = inner.0;
1239 let method = QuerySigningRequestByTxHashSvc(inner);
1240 let codec = tonic::codec::ProstCodec::default();
1241 let mut grpc = tonic::server::Grpc::new(codec)
1242 .apply_compression_config(
1243 accept_compression_encodings,
1244 send_compression_encodings,
1245 )
1246 .apply_max_message_size_config(
1247 max_decoding_message_size,
1248 max_encoding_message_size,
1249 );
1250 let res = grpc.unary(method, req).await;
1251 Ok(res)
1252 };
1253 Box::pin(fut)
1254 }
1255 "/side.btcbridge.Query/QueryPendingSigningRequests" => {
1256 #[allow(non_camel_case_types)]
1257 struct QueryPendingSigningRequestsSvc<T: Query>(pub Arc<T>);
1258 impl<T: Query>
1259 tonic::server::UnaryService<super::QueryPendingSigningRequestsRequest>
1260 for QueryPendingSigningRequestsSvc<T>
1261 {
1262 type Response = super::QueryPendingSigningRequestsResponse;
1263 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1264 fn call(
1265 &mut self,
1266 request: tonic::Request<super::QueryPendingSigningRequestsRequest>,
1267 ) -> Self::Future {
1268 let inner = Arc::clone(&self.0);
1269 let fut = async move {
1270 (*inner).query_pending_signing_requests(request).await
1271 };
1272 Box::pin(fut)
1273 }
1274 }
1275 let accept_compression_encodings = self.accept_compression_encodings;
1276 let send_compression_encodings = self.send_compression_encodings;
1277 let max_decoding_message_size = self.max_decoding_message_size;
1278 let max_encoding_message_size = self.max_encoding_message_size;
1279 let inner = self.inner.clone();
1280 let fut = async move {
1281 let inner = inner.0;
1282 let method = QueryPendingSigningRequestsSvc(inner);
1283 let codec = tonic::codec::ProstCodec::default();
1284 let mut grpc = tonic::server::Grpc::new(codec)
1285 .apply_compression_config(
1286 accept_compression_encodings,
1287 send_compression_encodings,
1288 )
1289 .apply_max_message_size_config(
1290 max_decoding_message_size,
1291 max_encoding_message_size,
1292 );
1293 let res = grpc.unary(method, req).await;
1294 Ok(res)
1295 };
1296 Box::pin(fut)
1297 }
1298 "/side.btcbridge.Query/QueryUTXOs" => {
1299 #[allow(non_camel_case_types)]
1300 struct QueryUTXOsSvc<T: Query>(pub Arc<T>);
1301 impl<T: Query> tonic::server::UnaryService<super::QueryUtxOsRequest> for QueryUTXOsSvc<T> {
1302 type Response = super::QueryUtxOsResponse;
1303 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1304 fn call(
1305 &mut self,
1306 request: tonic::Request<super::QueryUtxOsRequest>,
1307 ) -> Self::Future {
1308 let inner = Arc::clone(&self.0);
1309 let fut = async move { (*inner).query_utx_os(request).await };
1310 Box::pin(fut)
1311 }
1312 }
1313 let accept_compression_encodings = self.accept_compression_encodings;
1314 let send_compression_encodings = self.send_compression_encodings;
1315 let max_decoding_message_size = self.max_decoding_message_size;
1316 let max_encoding_message_size = self.max_encoding_message_size;
1317 let inner = self.inner.clone();
1318 let fut = async move {
1319 let inner = inner.0;
1320 let method = QueryUTXOsSvc(inner);
1321 let codec = tonic::codec::ProstCodec::default();
1322 let mut grpc = tonic::server::Grpc::new(codec)
1323 .apply_compression_config(
1324 accept_compression_encodings,
1325 send_compression_encodings,
1326 )
1327 .apply_max_message_size_config(
1328 max_decoding_message_size,
1329 max_encoding_message_size,
1330 );
1331 let res = grpc.unary(method, req).await;
1332 Ok(res)
1333 };
1334 Box::pin(fut)
1335 }
1336 "/side.btcbridge.Query/QueryUTXOsByAddress" => {
1337 #[allow(non_camel_case_types)]
1338 struct QueryUTXOsByAddressSvc<T: Query>(pub Arc<T>);
1339 impl<T: Query> tonic::server::UnaryService<super::QueryUtxOsByAddressRequest>
1340 for QueryUTXOsByAddressSvc<T>
1341 {
1342 type Response = super::QueryUtxOsByAddressResponse;
1343 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1344 fn call(
1345 &mut self,
1346 request: tonic::Request<super::QueryUtxOsByAddressRequest>,
1347 ) -> Self::Future {
1348 let inner = Arc::clone(&self.0);
1349 let fut =
1350 async move { (*inner).query_utx_os_by_address(request).await };
1351 Box::pin(fut)
1352 }
1353 }
1354 let accept_compression_encodings = self.accept_compression_encodings;
1355 let send_compression_encodings = self.send_compression_encodings;
1356 let max_decoding_message_size = self.max_decoding_message_size;
1357 let max_encoding_message_size = self.max_encoding_message_size;
1358 let inner = self.inner.clone();
1359 let fut = async move {
1360 let inner = inner.0;
1361 let method = QueryUTXOsByAddressSvc(inner);
1362 let codec = tonic::codec::ProstCodec::default();
1363 let mut grpc = tonic::server::Grpc::new(codec)
1364 .apply_compression_config(
1365 accept_compression_encodings,
1366 send_compression_encodings,
1367 )
1368 .apply_max_message_size_config(
1369 max_decoding_message_size,
1370 max_encoding_message_size,
1371 );
1372 let res = grpc.unary(method, req).await;
1373 Ok(res)
1374 };
1375 Box::pin(fut)
1376 }
1377 "/side.btcbridge.Query/QueryUTXOCountAndBalancesByAddress" => {
1378 #[allow(non_camel_case_types)]
1379 struct QueryUTXOCountAndBalancesByAddressSvc<T: Query>(pub Arc<T>);
1380 impl<T: Query>
1381 tonic::server::UnaryService<
1382 super::QueryUtxoCountAndBalancesByAddressRequest,
1383 > for QueryUTXOCountAndBalancesByAddressSvc<T>
1384 {
1385 type Response = super::QueryUtxoCountAndBalancesByAddressResponse;
1386 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1387 fn call(
1388 &mut self,
1389 request: tonic::Request<
1390 super::QueryUtxoCountAndBalancesByAddressRequest,
1391 >,
1392 ) -> Self::Future {
1393 let inner = Arc::clone(&self.0);
1394 let fut = async move {
1395 (*inner)
1396 .query_utxo_count_and_balances_by_address(request)
1397 .await
1398 };
1399 Box::pin(fut)
1400 }
1401 }
1402 let accept_compression_encodings = self.accept_compression_encodings;
1403 let send_compression_encodings = self.send_compression_encodings;
1404 let max_decoding_message_size = self.max_decoding_message_size;
1405 let max_encoding_message_size = self.max_encoding_message_size;
1406 let inner = self.inner.clone();
1407 let fut = async move {
1408 let inner = inner.0;
1409 let method = QueryUTXOCountAndBalancesByAddressSvc(inner);
1410 let codec = tonic::codec::ProstCodec::default();
1411 let mut grpc = tonic::server::Grpc::new(codec)
1412 .apply_compression_config(
1413 accept_compression_encodings,
1414 send_compression_encodings,
1415 )
1416 .apply_max_message_size_config(
1417 max_decoding_message_size,
1418 max_encoding_message_size,
1419 );
1420 let res = grpc.unary(method, req).await;
1421 Ok(res)
1422 };
1423 Box::pin(fut)
1424 }
1425 "/side.btcbridge.Query/QueryDKGRequest" => {
1426 #[allow(non_camel_case_types)]
1427 struct QueryDKGRequestSvc<T: Query>(pub Arc<T>);
1428 impl<T: Query> tonic::server::UnaryService<super::QueryDkgRequestRequest>
1429 for QueryDKGRequestSvc<T>
1430 {
1431 type Response = super::QueryDkgRequestResponse;
1432 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1433 fn call(
1434 &mut self,
1435 request: tonic::Request<super::QueryDkgRequestRequest>,
1436 ) -> Self::Future {
1437 let inner = Arc::clone(&self.0);
1438 let fut = async move { (*inner).query_dkg_request(request).await };
1439 Box::pin(fut)
1440 }
1441 }
1442 let accept_compression_encodings = self.accept_compression_encodings;
1443 let send_compression_encodings = self.send_compression_encodings;
1444 let max_decoding_message_size = self.max_decoding_message_size;
1445 let max_encoding_message_size = self.max_encoding_message_size;
1446 let inner = self.inner.clone();
1447 let fut = async move {
1448 let inner = inner.0;
1449 let method = QueryDKGRequestSvc(inner);
1450 let codec = tonic::codec::ProstCodec::default();
1451 let mut grpc = tonic::server::Grpc::new(codec)
1452 .apply_compression_config(
1453 accept_compression_encodings,
1454 send_compression_encodings,
1455 )
1456 .apply_max_message_size_config(
1457 max_decoding_message_size,
1458 max_encoding_message_size,
1459 );
1460 let res = grpc.unary(method, req).await;
1461 Ok(res)
1462 };
1463 Box::pin(fut)
1464 }
1465 "/side.btcbridge.Query/QueryDKGRequests" => {
1466 #[allow(non_camel_case_types)]
1467 struct QueryDKGRequestsSvc<T: Query>(pub Arc<T>);
1468 impl<T: Query> tonic::server::UnaryService<super::QueryDkgRequestsRequest>
1469 for QueryDKGRequestsSvc<T>
1470 {
1471 type Response = super::QueryDkgRequestsResponse;
1472 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1473 fn call(
1474 &mut self,
1475 request: tonic::Request<super::QueryDkgRequestsRequest>,
1476 ) -> Self::Future {
1477 let inner = Arc::clone(&self.0);
1478 let fut = async move { (*inner).query_dkg_requests(request).await };
1479 Box::pin(fut)
1480 }
1481 }
1482 let accept_compression_encodings = self.accept_compression_encodings;
1483 let send_compression_encodings = self.send_compression_encodings;
1484 let max_decoding_message_size = self.max_decoding_message_size;
1485 let max_encoding_message_size = self.max_encoding_message_size;
1486 let inner = self.inner.clone();
1487 let fut = async move {
1488 let inner = inner.0;
1489 let method = QueryDKGRequestsSvc(inner);
1490 let codec = tonic::codec::ProstCodec::default();
1491 let mut grpc = tonic::server::Grpc::new(codec)
1492 .apply_compression_config(
1493 accept_compression_encodings,
1494 send_compression_encodings,
1495 )
1496 .apply_max_message_size_config(
1497 max_decoding_message_size,
1498 max_encoding_message_size,
1499 );
1500 let res = grpc.unary(method, req).await;
1501 Ok(res)
1502 };
1503 Box::pin(fut)
1504 }
1505 "/side.btcbridge.Query/QueryAllDKGRequests" => {
1506 #[allow(non_camel_case_types)]
1507 struct QueryAllDKGRequestsSvc<T: Query>(pub Arc<T>);
1508 impl<T: Query> tonic::server::UnaryService<super::QueryAllDkgRequestsRequest>
1509 for QueryAllDKGRequestsSvc<T>
1510 {
1511 type Response = super::QueryAllDkgRequestsResponse;
1512 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1513 fn call(
1514 &mut self,
1515 request: tonic::Request<super::QueryAllDkgRequestsRequest>,
1516 ) -> Self::Future {
1517 let inner = Arc::clone(&self.0);
1518 let fut = async move { (*inner).query_all_dkg_requests(request).await };
1519 Box::pin(fut)
1520 }
1521 }
1522 let accept_compression_encodings = self.accept_compression_encodings;
1523 let send_compression_encodings = self.send_compression_encodings;
1524 let max_decoding_message_size = self.max_decoding_message_size;
1525 let max_encoding_message_size = self.max_encoding_message_size;
1526 let inner = self.inner.clone();
1527 let fut = async move {
1528 let inner = inner.0;
1529 let method = QueryAllDKGRequestsSvc(inner);
1530 let codec = tonic::codec::ProstCodec::default();
1531 let mut grpc = tonic::server::Grpc::new(codec)
1532 .apply_compression_config(
1533 accept_compression_encodings,
1534 send_compression_encodings,
1535 )
1536 .apply_max_message_size_config(
1537 max_decoding_message_size,
1538 max_encoding_message_size,
1539 );
1540 let res = grpc.unary(method, req).await;
1541 Ok(res)
1542 };
1543 Box::pin(fut)
1544 }
1545 "/side.btcbridge.Query/QueryDKGCompletionRequests" => {
1546 #[allow(non_camel_case_types)]
1547 struct QueryDKGCompletionRequestsSvc<T: Query>(pub Arc<T>);
1548 impl<T: Query>
1549 tonic::server::UnaryService<super::QueryDkgCompletionRequestsRequest>
1550 for QueryDKGCompletionRequestsSvc<T>
1551 {
1552 type Response = super::QueryDkgCompletionRequestsResponse;
1553 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1554 fn call(
1555 &mut self,
1556 request: tonic::Request<super::QueryDkgCompletionRequestsRequest>,
1557 ) -> Self::Future {
1558 let inner = Arc::clone(&self.0);
1559 let fut = async move {
1560 (*inner).query_dkg_completion_requests(request).await
1561 };
1562 Box::pin(fut)
1563 }
1564 }
1565 let accept_compression_encodings = self.accept_compression_encodings;
1566 let send_compression_encodings = self.send_compression_encodings;
1567 let max_decoding_message_size = self.max_decoding_message_size;
1568 let max_encoding_message_size = self.max_encoding_message_size;
1569 let inner = self.inner.clone();
1570 let fut = async move {
1571 let inner = inner.0;
1572 let method = QueryDKGCompletionRequestsSvc(inner);
1573 let codec = tonic::codec::ProstCodec::default();
1574 let mut grpc = tonic::server::Grpc::new(codec)
1575 .apply_compression_config(
1576 accept_compression_encodings,
1577 send_compression_encodings,
1578 )
1579 .apply_max_message_size_config(
1580 max_decoding_message_size,
1581 max_encoding_message_size,
1582 );
1583 let res = grpc.unary(method, req).await;
1584 Ok(res)
1585 };
1586 Box::pin(fut)
1587 }
1588 "/side.btcbridge.Query/QueryRefreshingRequest" => {
1589 #[allow(non_camel_case_types)]
1590 struct QueryRefreshingRequestSvc<T: Query>(pub Arc<T>);
1591 impl<T: Query> tonic::server::UnaryService<super::QueryRefreshingRequestRequest>
1592 for QueryRefreshingRequestSvc<T>
1593 {
1594 type Response = super::QueryRefreshingRequestResponse;
1595 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1596 fn call(
1597 &mut self,
1598 request: tonic::Request<super::QueryRefreshingRequestRequest>,
1599 ) -> Self::Future {
1600 let inner = Arc::clone(&self.0);
1601 let fut =
1602 async move { (*inner).query_refreshing_request(request).await };
1603 Box::pin(fut)
1604 }
1605 }
1606 let accept_compression_encodings = self.accept_compression_encodings;
1607 let send_compression_encodings = self.send_compression_encodings;
1608 let max_decoding_message_size = self.max_decoding_message_size;
1609 let max_encoding_message_size = self.max_encoding_message_size;
1610 let inner = self.inner.clone();
1611 let fut = async move {
1612 let inner = inner.0;
1613 let method = QueryRefreshingRequestSvc(inner);
1614 let codec = tonic::codec::ProstCodec::default();
1615 let mut grpc = tonic::server::Grpc::new(codec)
1616 .apply_compression_config(
1617 accept_compression_encodings,
1618 send_compression_encodings,
1619 )
1620 .apply_max_message_size_config(
1621 max_decoding_message_size,
1622 max_encoding_message_size,
1623 );
1624 let res = grpc.unary(method, req).await;
1625 Ok(res)
1626 };
1627 Box::pin(fut)
1628 }
1629 "/side.btcbridge.Query/QueryRefreshingRequests" => {
1630 #[allow(non_camel_case_types)]
1631 struct QueryRefreshingRequestsSvc<T: Query>(pub Arc<T>);
1632 impl<T: Query>
1633 tonic::server::UnaryService<super::QueryRefreshingRequestsRequest>
1634 for QueryRefreshingRequestsSvc<T>
1635 {
1636 type Response = super::QueryRefreshingRequestsResponse;
1637 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1638 fn call(
1639 &mut self,
1640 request: tonic::Request<super::QueryRefreshingRequestsRequest>,
1641 ) -> Self::Future {
1642 let inner = Arc::clone(&self.0);
1643 let fut =
1644 async move { (*inner).query_refreshing_requests(request).await };
1645 Box::pin(fut)
1646 }
1647 }
1648 let accept_compression_encodings = self.accept_compression_encodings;
1649 let send_compression_encodings = self.send_compression_encodings;
1650 let max_decoding_message_size = self.max_decoding_message_size;
1651 let max_encoding_message_size = self.max_encoding_message_size;
1652 let inner = self.inner.clone();
1653 let fut = async move {
1654 let inner = inner.0;
1655 let method = QueryRefreshingRequestsSvc(inner);
1656 let codec = tonic::codec::ProstCodec::default();
1657 let mut grpc = tonic::server::Grpc::new(codec)
1658 .apply_compression_config(
1659 accept_compression_encodings,
1660 send_compression_encodings,
1661 )
1662 .apply_max_message_size_config(
1663 max_decoding_message_size,
1664 max_encoding_message_size,
1665 );
1666 let res = grpc.unary(method, req).await;
1667 Ok(res)
1668 };
1669 Box::pin(fut)
1670 }
1671 "/side.btcbridge.Query/QueryRefreshingCompletions" => {
1672 #[allow(non_camel_case_types)]
1673 struct QueryRefreshingCompletionsSvc<T: Query>(pub Arc<T>);
1674 impl<T: Query>
1675 tonic::server::UnaryService<super::QueryRefreshingCompletionsRequest>
1676 for QueryRefreshingCompletionsSvc<T>
1677 {
1678 type Response = super::QueryRefreshingCompletionsResponse;
1679 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1680 fn call(
1681 &mut self,
1682 request: tonic::Request<super::QueryRefreshingCompletionsRequest>,
1683 ) -> Self::Future {
1684 let inner = Arc::clone(&self.0);
1685 let fut =
1686 async move { (*inner).query_refreshing_completions(request).await };
1687 Box::pin(fut)
1688 }
1689 }
1690 let accept_compression_encodings = self.accept_compression_encodings;
1691 let send_compression_encodings = self.send_compression_encodings;
1692 let max_decoding_message_size = self.max_decoding_message_size;
1693 let max_encoding_message_size = self.max_encoding_message_size;
1694 let inner = self.inner.clone();
1695 let fut = async move {
1696 let inner = inner.0;
1697 let method = QueryRefreshingCompletionsSvc(inner);
1698 let codec = tonic::codec::ProstCodec::default();
1699 let mut grpc = tonic::server::Grpc::new(codec)
1700 .apply_compression_config(
1701 accept_compression_encodings,
1702 send_compression_encodings,
1703 )
1704 .apply_max_message_size_config(
1705 max_decoding_message_size,
1706 max_encoding_message_size,
1707 );
1708 let res = grpc.unary(method, req).await;
1709 Ok(res)
1710 };
1711 Box::pin(fut)
1712 }
1713 "/side.btcbridge.Query/QueryIBCDepositScript" => {
1714 #[allow(non_camel_case_types)]
1715 struct QueryIBCDepositScriptSvc<T: Query>(pub Arc<T>);
1716 impl<T: Query> tonic::server::UnaryService<super::QueryIbcDepositScriptRequest>
1717 for QueryIBCDepositScriptSvc<T>
1718 {
1719 type Response = super::QueryIbcDepositScriptResponse;
1720 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1721 fn call(
1722 &mut self,
1723 request: tonic::Request<super::QueryIbcDepositScriptRequest>,
1724 ) -> Self::Future {
1725 let inner = Arc::clone(&self.0);
1726 let fut =
1727 async move { (*inner).query_ibc_deposit_script(request).await };
1728 Box::pin(fut)
1729 }
1730 }
1731 let accept_compression_encodings = self.accept_compression_encodings;
1732 let send_compression_encodings = self.send_compression_encodings;
1733 let max_decoding_message_size = self.max_decoding_message_size;
1734 let max_encoding_message_size = self.max_encoding_message_size;
1735 let inner = self.inner.clone();
1736 let fut = async move {
1737 let inner = inner.0;
1738 let method = QueryIBCDepositScriptSvc(inner);
1739 let codec = tonic::codec::ProstCodec::default();
1740 let mut grpc = tonic::server::Grpc::new(codec)
1741 .apply_compression_config(
1742 accept_compression_encodings,
1743 send_compression_encodings,
1744 )
1745 .apply_max_message_size_config(
1746 max_decoding_message_size,
1747 max_encoding_message_size,
1748 );
1749 let res = grpc.unary(method, req).await;
1750 Ok(res)
1751 };
1752 Box::pin(fut)
1753 }
1754 "/side.btcbridge.Query/QueryRateLimit" => {
1755 #[allow(non_camel_case_types)]
1756 struct QueryRateLimitSvc<T: Query>(pub Arc<T>);
1757 impl<T: Query> tonic::server::UnaryService<super::QueryRateLimitRequest> for QueryRateLimitSvc<T> {
1758 type Response = super::QueryRateLimitResponse;
1759 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1760 fn call(
1761 &mut self,
1762 request: tonic::Request<super::QueryRateLimitRequest>,
1763 ) -> Self::Future {
1764 let inner = Arc::clone(&self.0);
1765 let fut = async move { (*inner).query_rate_limit(request).await };
1766 Box::pin(fut)
1767 }
1768 }
1769 let accept_compression_encodings = self.accept_compression_encodings;
1770 let send_compression_encodings = self.send_compression_encodings;
1771 let max_decoding_message_size = self.max_decoding_message_size;
1772 let max_encoding_message_size = self.max_encoding_message_size;
1773 let inner = self.inner.clone();
1774 let fut = async move {
1775 let inner = inner.0;
1776 let method = QueryRateLimitSvc(inner);
1777 let codec = tonic::codec::ProstCodec::default();
1778 let mut grpc = tonic::server::Grpc::new(codec)
1779 .apply_compression_config(
1780 accept_compression_encodings,
1781 send_compression_encodings,
1782 )
1783 .apply_max_message_size_config(
1784 max_decoding_message_size,
1785 max_encoding_message_size,
1786 );
1787 let res = grpc.unary(method, req).await;
1788 Ok(res)
1789 };
1790 Box::pin(fut)
1791 }
1792 "/side.btcbridge.Query/QueryRateLimitByAddress" => {
1793 #[allow(non_camel_case_types)]
1794 struct QueryRateLimitByAddressSvc<T: Query>(pub Arc<T>);
1795 impl<T: Query>
1796 tonic::server::UnaryService<super::QueryRateLimitByAddressRequest>
1797 for QueryRateLimitByAddressSvc<T>
1798 {
1799 type Response = super::QueryRateLimitByAddressResponse;
1800 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1801 fn call(
1802 &mut self,
1803 request: tonic::Request<super::QueryRateLimitByAddressRequest>,
1804 ) -> Self::Future {
1805 let inner = Arc::clone(&self.0);
1806 let fut =
1807 async move { (*inner).query_rate_limit_by_address(request).await };
1808 Box::pin(fut)
1809 }
1810 }
1811 let accept_compression_encodings = self.accept_compression_encodings;
1812 let send_compression_encodings = self.send_compression_encodings;
1813 let max_decoding_message_size = self.max_decoding_message_size;
1814 let max_encoding_message_size = self.max_encoding_message_size;
1815 let inner = self.inner.clone();
1816 let fut = async move {
1817 let inner = inner.0;
1818 let method = QueryRateLimitByAddressSvc(inner);
1819 let codec = tonic::codec::ProstCodec::default();
1820 let mut grpc = tonic::server::Grpc::new(codec)
1821 .apply_compression_config(
1822 accept_compression_encodings,
1823 send_compression_encodings,
1824 )
1825 .apply_max_message_size_config(
1826 max_decoding_message_size,
1827 max_encoding_message_size,
1828 );
1829 let res = grpc.unary(method, req).await;
1830 Ok(res)
1831 };
1832 Box::pin(fut)
1833 }
1834 _ => Box::pin(async move {
1835 Ok(http::Response::builder()
1836 .status(200)
1837 .header("grpc-status", "12")
1838 .header("content-type", "application/grpc")
1839 .body(empty_body())
1840 .unwrap())
1841 }),
1842 }
1843 }
1844 }
1845 impl<T: Query> Clone for QueryServer<T> {
1846 fn clone(&self) -> Self {
1847 let inner = self.inner.clone();
1848 Self {
1849 inner,
1850 accept_compression_encodings: self.accept_compression_encodings,
1851 send_compression_encodings: self.send_compression_encodings,
1852 max_decoding_message_size: self.max_decoding_message_size,
1853 max_encoding_message_size: self.max_encoding_message_size,
1854 }
1855 }
1856 }
1857 impl<T: Query> Clone for _Inner<T> {
1858 fn clone(&self) -> Self {
1859 Self(Arc::clone(&self.0))
1860 }
1861 }
1862 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
1863 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1864 write!(f, "{:?}", self.0)
1865 }
1866 }
1867 impl<T: Query> tonic::server::NamedService for QueryServer<T> {
1868 const NAME: &'static str = "side.btcbridge.Query";
1869 }
1870}
1871#[cfg(feature = "grpc")]
1873pub mod msg_client {
1874 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1875 use tonic::codegen::http::Uri;
1876 use tonic::codegen::*;
1877 #[derive(Debug, Clone)]
1878 pub struct MsgClient<T> {
1879 inner: tonic::client::Grpc<T>,
1880 }
1881 #[cfg(feature = "grpc-transport")]
1882 impl MsgClient<tonic::transport::Channel> {
1883 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1885 where
1886 D: TryInto<tonic::transport::Endpoint>,
1887 D::Error: Into<StdError>,
1888 {
1889 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1890 Ok(Self::new(conn))
1891 }
1892 }
1893 impl<T> MsgClient<T>
1894 where
1895 T: tonic::client::GrpcService<tonic::body::BoxBody>,
1896 T::Error: Into<StdError>,
1897 T::ResponseBody: Body<Data = Bytes> + Send + 'static,
1898 <T::ResponseBody as Body>::Error: Into<StdError> + Send,
1899 {
1900 pub fn new(inner: T) -> Self {
1901 let inner = tonic::client::Grpc::new(inner);
1902 Self { inner }
1903 }
1904 pub fn with_origin(inner: T, origin: Uri) -> Self {
1905 let inner = tonic::client::Grpc::with_origin(inner, origin);
1906 Self { inner }
1907 }
1908 pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
1909 where
1910 F: tonic::service::Interceptor,
1911 T::ResponseBody: Default,
1912 T: tonic::codegen::Service<
1913 http::Request<tonic::body::BoxBody>,
1914 Response = http::Response<
1915 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1916 >,
1917 >,
1918 <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
1919 Into<StdError> + Send + Sync,
1920 {
1921 MsgClient::new(InterceptedService::new(inner, interceptor))
1922 }
1923 #[must_use]
1928 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1929 self.inner = self.inner.send_compressed(encoding);
1930 self
1931 }
1932 #[must_use]
1934 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1935 self.inner = self.inner.accept_compressed(encoding);
1936 self
1937 }
1938 #[must_use]
1942 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1943 self.inner = self.inner.max_decoding_message_size(limit);
1944 self
1945 }
1946 #[must_use]
1950 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1951 self.inner = self.inner.max_encoding_message_size(limit);
1952 self
1953 }
1954 pub async fn submit_deposit_transaction(
1955 &mut self,
1956 request: impl tonic::IntoRequest<super::MsgSubmitDepositTransaction>,
1957 ) -> core::result::Result<
1958 tonic::Response<super::MsgSubmitDepositTransactionResponse>,
1959 tonic::Status,
1960 > {
1961 self.inner.ready().await.map_err(|e| {
1962 tonic::Status::new(
1963 tonic::Code::Unknown,
1964 alloc::format!("Service was not ready: {}", e.into()),
1965 )
1966 })?;
1967 let codec = tonic::codec::ProstCodec::default();
1968 let path = http::uri::PathAndQuery::from_static(
1969 "/side.btcbridge.Msg/SubmitDepositTransaction",
1970 );
1971 let mut req = request.into_request();
1972 req.extensions_mut().insert(GrpcMethod::new(
1973 "side.btcbridge.Msg",
1974 "SubmitDepositTransaction",
1975 ));
1976 self.inner.unary(req, path, codec).await
1977 }
1978 pub async fn submit_withdraw_transaction(
1979 &mut self,
1980 request: impl tonic::IntoRequest<super::MsgSubmitWithdrawTransaction>,
1981 ) -> core::result::Result<
1982 tonic::Response<super::MsgSubmitWithdrawTransactionResponse>,
1983 tonic::Status,
1984 > {
1985 self.inner.ready().await.map_err(|e| {
1986 tonic::Status::new(
1987 tonic::Code::Unknown,
1988 alloc::format!("Service was not ready: {}", e.into()),
1989 )
1990 })?;
1991 let codec = tonic::codec::ProstCodec::default();
1992 let path = http::uri::PathAndQuery::from_static(
1993 "/side.btcbridge.Msg/SubmitWithdrawTransaction",
1994 );
1995 let mut req = request.into_request();
1996 req.extensions_mut().insert(GrpcMethod::new(
1997 "side.btcbridge.Msg",
1998 "SubmitWithdrawTransaction",
1999 ));
2000 self.inner.unary(req, path, codec).await
2001 }
2002 pub async fn submit_fee_rate(
2003 &mut self,
2004 request: impl tonic::IntoRequest<super::MsgSubmitFeeRate>,
2005 ) -> core::result::Result<tonic::Response<super::MsgSubmitFeeRateResponse>, tonic::Status>
2006 {
2007 self.inner.ready().await.map_err(|e| {
2008 tonic::Status::new(
2009 tonic::Code::Unknown,
2010 alloc::format!("Service was not ready: {}", e.into()),
2011 )
2012 })?;
2013 let codec = tonic::codec::ProstCodec::default();
2014 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/SubmitFeeRate");
2015 let mut req = request.into_request();
2016 req.extensions_mut()
2017 .insert(GrpcMethod::new("side.btcbridge.Msg", "SubmitFeeRate"));
2018 self.inner.unary(req, path, codec).await
2019 }
2020 pub async fn update_trusted_non_btc_relayers(
2021 &mut self,
2022 request: impl tonic::IntoRequest<super::MsgUpdateTrustedNonBtcRelayers>,
2023 ) -> core::result::Result<
2024 tonic::Response<super::MsgUpdateTrustedNonBtcRelayersResponse>,
2025 tonic::Status,
2026 > {
2027 self.inner.ready().await.map_err(|e| {
2028 tonic::Status::new(
2029 tonic::Code::Unknown,
2030 alloc::format!("Service was not ready: {}", e.into()),
2031 )
2032 })?;
2033 let codec = tonic::codec::ProstCodec::default();
2034 let path = http::uri::PathAndQuery::from_static(
2035 "/side.btcbridge.Msg/UpdateTrustedNonBtcRelayers",
2036 );
2037 let mut req = request.into_request();
2038 req.extensions_mut().insert(GrpcMethod::new(
2039 "side.btcbridge.Msg",
2040 "UpdateTrustedNonBtcRelayers",
2041 ));
2042 self.inner.unary(req, path, codec).await
2043 }
2044 pub async fn update_trusted_fee_providers(
2045 &mut self,
2046 request: impl tonic::IntoRequest<super::MsgUpdateTrustedFeeProviders>,
2047 ) -> core::result::Result<
2048 tonic::Response<super::MsgUpdateTrustedFeeProvidersResponse>,
2049 tonic::Status,
2050 > {
2051 self.inner.ready().await.map_err(|e| {
2052 tonic::Status::new(
2053 tonic::Code::Unknown,
2054 alloc::format!("Service was not ready: {}", e.into()),
2055 )
2056 })?;
2057 let codec = tonic::codec::ProstCodec::default();
2058 let path = http::uri::PathAndQuery::from_static(
2059 "/side.btcbridge.Msg/UpdateTrustedFeeProviders",
2060 );
2061 let mut req = request.into_request();
2062 req.extensions_mut().insert(GrpcMethod::new(
2063 "side.btcbridge.Msg",
2064 "UpdateTrustedFeeProviders",
2065 ));
2066 self.inner.unary(req, path, codec).await
2067 }
2068 pub async fn withdraw_to_bitcoin(
2069 &mut self,
2070 request: impl tonic::IntoRequest<super::MsgWithdrawToBitcoin>,
2071 ) -> core::result::Result<tonic::Response<super::MsgWithdrawToBitcoinResponse>, tonic::Status>
2072 {
2073 self.inner.ready().await.map_err(|e| {
2074 tonic::Status::new(
2075 tonic::Code::Unknown,
2076 alloc::format!("Service was not ready: {}", e.into()),
2077 )
2078 })?;
2079 let codec = tonic::codec::ProstCodec::default();
2080 let path =
2081 http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/WithdrawToBitcoin");
2082 let mut req = request.into_request();
2083 req.extensions_mut()
2084 .insert(GrpcMethod::new("side.btcbridge.Msg", "WithdrawToBitcoin"));
2085 self.inner.unary(req, path, codec).await
2086 }
2087 pub async fn submit_signatures(
2088 &mut self,
2089 request: impl tonic::IntoRequest<super::MsgSubmitSignatures>,
2090 ) -> core::result::Result<tonic::Response<super::MsgSubmitSignaturesResponse>, tonic::Status>
2091 {
2092 self.inner.ready().await.map_err(|e| {
2093 tonic::Status::new(
2094 tonic::Code::Unknown,
2095 alloc::format!("Service was not ready: {}", e.into()),
2096 )
2097 })?;
2098 let codec = tonic::codec::ProstCodec::default();
2099 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/SubmitSignatures");
2100 let mut req = request.into_request();
2101 req.extensions_mut()
2102 .insert(GrpcMethod::new("side.btcbridge.Msg", "SubmitSignatures"));
2103 self.inner.unary(req, path, codec).await
2104 }
2105 pub async fn consolidate_vaults(
2106 &mut self,
2107 request: impl tonic::IntoRequest<super::MsgConsolidateVaults>,
2108 ) -> core::result::Result<tonic::Response<super::MsgConsolidateVaultsResponse>, tonic::Status>
2109 {
2110 self.inner.ready().await.map_err(|e| {
2111 tonic::Status::new(
2112 tonic::Code::Unknown,
2113 alloc::format!("Service was not ready: {}", e.into()),
2114 )
2115 })?;
2116 let codec = tonic::codec::ProstCodec::default();
2117 let path =
2118 http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/ConsolidateVaults");
2119 let mut req = request.into_request();
2120 req.extensions_mut()
2121 .insert(GrpcMethod::new("side.btcbridge.Msg", "ConsolidateVaults"));
2122 self.inner.unary(req, path, codec).await
2123 }
2124 pub async fn initiate_dkg(
2125 &mut self,
2126 request: impl tonic::IntoRequest<super::MsgInitiateDkg>,
2127 ) -> core::result::Result<tonic::Response<super::MsgInitiateDkgResponse>, tonic::Status>
2128 {
2129 self.inner.ready().await.map_err(|e| {
2130 tonic::Status::new(
2131 tonic::Code::Unknown,
2132 alloc::format!("Service was not ready: {}", e.into()),
2133 )
2134 })?;
2135 let codec = tonic::codec::ProstCodec::default();
2136 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/InitiateDKG");
2137 let mut req = request.into_request();
2138 req.extensions_mut()
2139 .insert(GrpcMethod::new("side.btcbridge.Msg", "InitiateDKG"));
2140 self.inner.unary(req, path, codec).await
2141 }
2142 pub async fn complete_dkg(
2143 &mut self,
2144 request: impl tonic::IntoRequest<super::MsgCompleteDkg>,
2145 ) -> core::result::Result<tonic::Response<super::MsgCompleteDkgResponse>, tonic::Status>
2146 {
2147 self.inner.ready().await.map_err(|e| {
2148 tonic::Status::new(
2149 tonic::Code::Unknown,
2150 alloc::format!("Service was not ready: {}", e.into()),
2151 )
2152 })?;
2153 let codec = tonic::codec::ProstCodec::default();
2154 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/CompleteDKG");
2155 let mut req = request.into_request();
2156 req.extensions_mut()
2157 .insert(GrpcMethod::new("side.btcbridge.Msg", "CompleteDKG"));
2158 self.inner.unary(req, path, codec).await
2159 }
2160 pub async fn refresh(
2161 &mut self,
2162 request: impl tonic::IntoRequest<super::MsgRefresh>,
2163 ) -> core::result::Result<tonic::Response<super::MsgRefreshResponse>, tonic::Status>
2164 {
2165 self.inner.ready().await.map_err(|e| {
2166 tonic::Status::new(
2167 tonic::Code::Unknown,
2168 alloc::format!("Service was not ready: {}", e.into()),
2169 )
2170 })?;
2171 let codec = tonic::codec::ProstCodec::default();
2172 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/Refresh");
2173 let mut req = request.into_request();
2174 req.extensions_mut()
2175 .insert(GrpcMethod::new("side.btcbridge.Msg", "Refresh"));
2176 self.inner.unary(req, path, codec).await
2177 }
2178 pub async fn complete_refreshing(
2179 &mut self,
2180 request: impl tonic::IntoRequest<super::MsgCompleteRefreshing>,
2181 ) -> core::result::Result<
2182 tonic::Response<super::MsgCompleteRefreshingResponse>,
2183 tonic::Status,
2184 > {
2185 self.inner.ready().await.map_err(|e| {
2186 tonic::Status::new(
2187 tonic::Code::Unknown,
2188 alloc::format!("Service was not ready: {}", e.into()),
2189 )
2190 })?;
2191 let codec = tonic::codec::ProstCodec::default();
2192 let path =
2193 http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/CompleteRefreshing");
2194 let mut req = request.into_request();
2195 req.extensions_mut()
2196 .insert(GrpcMethod::new("side.btcbridge.Msg", "CompleteRefreshing"));
2197 self.inner.unary(req, path, codec).await
2198 }
2199 pub async fn transfer_vault(
2200 &mut self,
2201 request: impl tonic::IntoRequest<super::MsgTransferVault>,
2202 ) -> core::result::Result<tonic::Response<super::MsgTransferVaultResponse>, tonic::Status>
2203 {
2204 self.inner.ready().await.map_err(|e| {
2205 tonic::Status::new(
2206 tonic::Code::Unknown,
2207 alloc::format!("Service was not ready: {}", e.into()),
2208 )
2209 })?;
2210 let codec = tonic::codec::ProstCodec::default();
2211 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/TransferVault");
2212 let mut req = request.into_request();
2213 req.extensions_mut()
2214 .insert(GrpcMethod::new("side.btcbridge.Msg", "TransferVault"));
2215 self.inner.unary(req, path, codec).await
2216 }
2217 pub async fn update_params(
2218 &mut self,
2219 request: impl tonic::IntoRequest<super::MsgUpdateParams>,
2220 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>
2221 {
2222 self.inner.ready().await.map_err(|e| {
2223 tonic::Status::new(
2224 tonic::Code::Unknown,
2225 alloc::format!("Service was not ready: {}", e.into()),
2226 )
2227 })?;
2228 let codec = tonic::codec::ProstCodec::default();
2229 let path = http::uri::PathAndQuery::from_static("/side.btcbridge.Msg/UpdateParams");
2230 let mut req = request.into_request();
2231 req.extensions_mut()
2232 .insert(GrpcMethod::new("side.btcbridge.Msg", "UpdateParams"));
2233 self.inner.unary(req, path, codec).await
2234 }
2235 }
2236}
2237#[cfg(feature = "grpc")]
2239pub mod msg_server {
2240 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
2241 use tonic::codegen::*;
2242 #[async_trait]
2244 pub trait Msg: Send + Sync + 'static {
2245 async fn submit_deposit_transaction(
2246 &self,
2247 request: tonic::Request<super::MsgSubmitDepositTransaction>,
2248 ) -> core::result::Result<
2249 tonic::Response<super::MsgSubmitDepositTransactionResponse>,
2250 tonic::Status,
2251 >;
2252 async fn submit_withdraw_transaction(
2253 &self,
2254 request: tonic::Request<super::MsgSubmitWithdrawTransaction>,
2255 ) -> core::result::Result<
2256 tonic::Response<super::MsgSubmitWithdrawTransactionResponse>,
2257 tonic::Status,
2258 >;
2259 async fn submit_fee_rate(
2260 &self,
2261 request: tonic::Request<super::MsgSubmitFeeRate>,
2262 ) -> core::result::Result<tonic::Response<super::MsgSubmitFeeRateResponse>, tonic::Status>;
2263 async fn update_trusted_non_btc_relayers(
2264 &self,
2265 request: tonic::Request<super::MsgUpdateTrustedNonBtcRelayers>,
2266 ) -> core::result::Result<
2267 tonic::Response<super::MsgUpdateTrustedNonBtcRelayersResponse>,
2268 tonic::Status,
2269 >;
2270 async fn update_trusted_fee_providers(
2271 &self,
2272 request: tonic::Request<super::MsgUpdateTrustedFeeProviders>,
2273 ) -> core::result::Result<
2274 tonic::Response<super::MsgUpdateTrustedFeeProvidersResponse>,
2275 tonic::Status,
2276 >;
2277 async fn withdraw_to_bitcoin(
2278 &self,
2279 request: tonic::Request<super::MsgWithdrawToBitcoin>,
2280 ) -> core::result::Result<tonic::Response<super::MsgWithdrawToBitcoinResponse>, tonic::Status>;
2281 async fn submit_signatures(
2282 &self,
2283 request: tonic::Request<super::MsgSubmitSignatures>,
2284 ) -> core::result::Result<tonic::Response<super::MsgSubmitSignaturesResponse>, tonic::Status>;
2285 async fn consolidate_vaults(
2286 &self,
2287 request: tonic::Request<super::MsgConsolidateVaults>,
2288 ) -> core::result::Result<tonic::Response<super::MsgConsolidateVaultsResponse>, tonic::Status>;
2289 async fn initiate_dkg(
2290 &self,
2291 request: tonic::Request<super::MsgInitiateDkg>,
2292 ) -> core::result::Result<tonic::Response<super::MsgInitiateDkgResponse>, tonic::Status>;
2293 async fn complete_dkg(
2294 &self,
2295 request: tonic::Request<super::MsgCompleteDkg>,
2296 ) -> core::result::Result<tonic::Response<super::MsgCompleteDkgResponse>, tonic::Status>;
2297 async fn refresh(
2298 &self,
2299 request: tonic::Request<super::MsgRefresh>,
2300 ) -> core::result::Result<tonic::Response<super::MsgRefreshResponse>, tonic::Status>;
2301 async fn complete_refreshing(
2302 &self,
2303 request: tonic::Request<super::MsgCompleteRefreshing>,
2304 ) -> core::result::Result<
2305 tonic::Response<super::MsgCompleteRefreshingResponse>,
2306 tonic::Status,
2307 >;
2308 async fn transfer_vault(
2309 &self,
2310 request: tonic::Request<super::MsgTransferVault>,
2311 ) -> core::result::Result<tonic::Response<super::MsgTransferVaultResponse>, tonic::Status>;
2312 async fn update_params(
2313 &self,
2314 request: tonic::Request<super::MsgUpdateParams>,
2315 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>;
2316 }
2317 #[derive(Debug)]
2318 pub struct MsgServer<T: Msg> {
2319 inner: _Inner<T>,
2320 accept_compression_encodings: EnabledCompressionEncodings,
2321 send_compression_encodings: EnabledCompressionEncodings,
2322 max_decoding_message_size: Option<usize>,
2323 max_encoding_message_size: Option<usize>,
2324 }
2325 struct _Inner<T>(Arc<T>);
2326 impl<T: Msg> MsgServer<T> {
2327 pub fn new(inner: T) -> Self {
2328 Self::from_arc(Arc::new(inner))
2329 }
2330 pub fn from_arc(inner: Arc<T>) -> Self {
2331 let inner = _Inner(inner);
2332 Self {
2333 inner,
2334 accept_compression_encodings: Default::default(),
2335 send_compression_encodings: Default::default(),
2336 max_decoding_message_size: None,
2337 max_encoding_message_size: None,
2338 }
2339 }
2340 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
2341 where
2342 F: tonic::service::Interceptor,
2343 {
2344 InterceptedService::new(Self::new(inner), interceptor)
2345 }
2346 #[must_use]
2348 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2349 self.accept_compression_encodings.enable(encoding);
2350 self
2351 }
2352 #[must_use]
2354 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2355 self.send_compression_encodings.enable(encoding);
2356 self
2357 }
2358 #[must_use]
2362 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2363 self.max_decoding_message_size = Some(limit);
2364 self
2365 }
2366 #[must_use]
2370 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2371 self.max_encoding_message_size = Some(limit);
2372 self
2373 }
2374 }
2375 impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
2376 where
2377 T: Msg,
2378 B: Body + Send + 'static,
2379 B::Error: Into<StdError> + Send + 'static,
2380 {
2381 type Response = http::Response<tonic::body::BoxBody>;
2382 type Error = std::convert::Infallible;
2383 type Future = BoxFuture<Self::Response, Self::Error>;
2384 fn poll_ready(
2385 &mut self,
2386 _cx: &mut Context<'_>,
2387 ) -> Poll<core::result::Result<(), Self::Error>> {
2388 Poll::Ready(Ok(()))
2389 }
2390 fn call(&mut self, req: http::Request<B>) -> Self::Future {
2391 let inner = self.inner.clone();
2392 match req.uri().path() {
2393 "/side.btcbridge.Msg/SubmitDepositTransaction" => {
2394 #[allow(non_camel_case_types)]
2395 struct SubmitDepositTransactionSvc<T: Msg>(pub Arc<T>);
2396 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitDepositTransaction>
2397 for SubmitDepositTransactionSvc<T>
2398 {
2399 type Response = super::MsgSubmitDepositTransactionResponse;
2400 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2401 fn call(
2402 &mut self,
2403 request: tonic::Request<super::MsgSubmitDepositTransaction>,
2404 ) -> Self::Future {
2405 let inner = Arc::clone(&self.0);
2406 let fut =
2407 async move { (*inner).submit_deposit_transaction(request).await };
2408 Box::pin(fut)
2409 }
2410 }
2411 let accept_compression_encodings = self.accept_compression_encodings;
2412 let send_compression_encodings = self.send_compression_encodings;
2413 let max_decoding_message_size = self.max_decoding_message_size;
2414 let max_encoding_message_size = self.max_encoding_message_size;
2415 let inner = self.inner.clone();
2416 let fut = async move {
2417 let inner = inner.0;
2418 let method = SubmitDepositTransactionSvc(inner);
2419 let codec = tonic::codec::ProstCodec::default();
2420 let mut grpc = tonic::server::Grpc::new(codec)
2421 .apply_compression_config(
2422 accept_compression_encodings,
2423 send_compression_encodings,
2424 )
2425 .apply_max_message_size_config(
2426 max_decoding_message_size,
2427 max_encoding_message_size,
2428 );
2429 let res = grpc.unary(method, req).await;
2430 Ok(res)
2431 };
2432 Box::pin(fut)
2433 }
2434 "/side.btcbridge.Msg/SubmitWithdrawTransaction" => {
2435 #[allow(non_camel_case_types)]
2436 struct SubmitWithdrawTransactionSvc<T: Msg>(pub Arc<T>);
2437 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitWithdrawTransaction>
2438 for SubmitWithdrawTransactionSvc<T>
2439 {
2440 type Response = super::MsgSubmitWithdrawTransactionResponse;
2441 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2442 fn call(
2443 &mut self,
2444 request: tonic::Request<super::MsgSubmitWithdrawTransaction>,
2445 ) -> Self::Future {
2446 let inner = Arc::clone(&self.0);
2447 let fut =
2448 async move { (*inner).submit_withdraw_transaction(request).await };
2449 Box::pin(fut)
2450 }
2451 }
2452 let accept_compression_encodings = self.accept_compression_encodings;
2453 let send_compression_encodings = self.send_compression_encodings;
2454 let max_decoding_message_size = self.max_decoding_message_size;
2455 let max_encoding_message_size = self.max_encoding_message_size;
2456 let inner = self.inner.clone();
2457 let fut = async move {
2458 let inner = inner.0;
2459 let method = SubmitWithdrawTransactionSvc(inner);
2460 let codec = tonic::codec::ProstCodec::default();
2461 let mut grpc = tonic::server::Grpc::new(codec)
2462 .apply_compression_config(
2463 accept_compression_encodings,
2464 send_compression_encodings,
2465 )
2466 .apply_max_message_size_config(
2467 max_decoding_message_size,
2468 max_encoding_message_size,
2469 );
2470 let res = grpc.unary(method, req).await;
2471 Ok(res)
2472 };
2473 Box::pin(fut)
2474 }
2475 "/side.btcbridge.Msg/SubmitFeeRate" => {
2476 #[allow(non_camel_case_types)]
2477 struct SubmitFeeRateSvc<T: Msg>(pub Arc<T>);
2478 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitFeeRate> for SubmitFeeRateSvc<T> {
2479 type Response = super::MsgSubmitFeeRateResponse;
2480 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2481 fn call(
2482 &mut self,
2483 request: tonic::Request<super::MsgSubmitFeeRate>,
2484 ) -> Self::Future {
2485 let inner = Arc::clone(&self.0);
2486 let fut = async move { (*inner).submit_fee_rate(request).await };
2487 Box::pin(fut)
2488 }
2489 }
2490 let accept_compression_encodings = self.accept_compression_encodings;
2491 let send_compression_encodings = self.send_compression_encodings;
2492 let max_decoding_message_size = self.max_decoding_message_size;
2493 let max_encoding_message_size = self.max_encoding_message_size;
2494 let inner = self.inner.clone();
2495 let fut = async move {
2496 let inner = inner.0;
2497 let method = SubmitFeeRateSvc(inner);
2498 let codec = tonic::codec::ProstCodec::default();
2499 let mut grpc = tonic::server::Grpc::new(codec)
2500 .apply_compression_config(
2501 accept_compression_encodings,
2502 send_compression_encodings,
2503 )
2504 .apply_max_message_size_config(
2505 max_decoding_message_size,
2506 max_encoding_message_size,
2507 );
2508 let res = grpc.unary(method, req).await;
2509 Ok(res)
2510 };
2511 Box::pin(fut)
2512 }
2513 "/side.btcbridge.Msg/UpdateTrustedNonBtcRelayers" => {
2514 #[allow(non_camel_case_types)]
2515 struct UpdateTrustedNonBtcRelayersSvc<T: Msg>(pub Arc<T>);
2516 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateTrustedNonBtcRelayers>
2517 for UpdateTrustedNonBtcRelayersSvc<T>
2518 {
2519 type Response = super::MsgUpdateTrustedNonBtcRelayersResponse;
2520 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2521 fn call(
2522 &mut self,
2523 request: tonic::Request<super::MsgUpdateTrustedNonBtcRelayers>,
2524 ) -> Self::Future {
2525 let inner = Arc::clone(&self.0);
2526 let fut = async move {
2527 (*inner).update_trusted_non_btc_relayers(request).await
2528 };
2529 Box::pin(fut)
2530 }
2531 }
2532 let accept_compression_encodings = self.accept_compression_encodings;
2533 let send_compression_encodings = self.send_compression_encodings;
2534 let max_decoding_message_size = self.max_decoding_message_size;
2535 let max_encoding_message_size = self.max_encoding_message_size;
2536 let inner = self.inner.clone();
2537 let fut = async move {
2538 let inner = inner.0;
2539 let method = UpdateTrustedNonBtcRelayersSvc(inner);
2540 let codec = tonic::codec::ProstCodec::default();
2541 let mut grpc = tonic::server::Grpc::new(codec)
2542 .apply_compression_config(
2543 accept_compression_encodings,
2544 send_compression_encodings,
2545 )
2546 .apply_max_message_size_config(
2547 max_decoding_message_size,
2548 max_encoding_message_size,
2549 );
2550 let res = grpc.unary(method, req).await;
2551 Ok(res)
2552 };
2553 Box::pin(fut)
2554 }
2555 "/side.btcbridge.Msg/UpdateTrustedFeeProviders" => {
2556 #[allow(non_camel_case_types)]
2557 struct UpdateTrustedFeeProvidersSvc<T: Msg>(pub Arc<T>);
2558 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateTrustedFeeProviders>
2559 for UpdateTrustedFeeProvidersSvc<T>
2560 {
2561 type Response = super::MsgUpdateTrustedFeeProvidersResponse;
2562 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2563 fn call(
2564 &mut self,
2565 request: tonic::Request<super::MsgUpdateTrustedFeeProviders>,
2566 ) -> Self::Future {
2567 let inner = Arc::clone(&self.0);
2568 let fut =
2569 async move { (*inner).update_trusted_fee_providers(request).await };
2570 Box::pin(fut)
2571 }
2572 }
2573 let accept_compression_encodings = self.accept_compression_encodings;
2574 let send_compression_encodings = self.send_compression_encodings;
2575 let max_decoding_message_size = self.max_decoding_message_size;
2576 let max_encoding_message_size = self.max_encoding_message_size;
2577 let inner = self.inner.clone();
2578 let fut = async move {
2579 let inner = inner.0;
2580 let method = UpdateTrustedFeeProvidersSvc(inner);
2581 let codec = tonic::codec::ProstCodec::default();
2582 let mut grpc = tonic::server::Grpc::new(codec)
2583 .apply_compression_config(
2584 accept_compression_encodings,
2585 send_compression_encodings,
2586 )
2587 .apply_max_message_size_config(
2588 max_decoding_message_size,
2589 max_encoding_message_size,
2590 );
2591 let res = grpc.unary(method, req).await;
2592 Ok(res)
2593 };
2594 Box::pin(fut)
2595 }
2596 "/side.btcbridge.Msg/WithdrawToBitcoin" => {
2597 #[allow(non_camel_case_types)]
2598 struct WithdrawToBitcoinSvc<T: Msg>(pub Arc<T>);
2599 impl<T: Msg> tonic::server::UnaryService<super::MsgWithdrawToBitcoin> for WithdrawToBitcoinSvc<T> {
2600 type Response = super::MsgWithdrawToBitcoinResponse;
2601 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2602 fn call(
2603 &mut self,
2604 request: tonic::Request<super::MsgWithdrawToBitcoin>,
2605 ) -> Self::Future {
2606 let inner = Arc::clone(&self.0);
2607 let fut = async move { (*inner).withdraw_to_bitcoin(request).await };
2608 Box::pin(fut)
2609 }
2610 }
2611 let accept_compression_encodings = self.accept_compression_encodings;
2612 let send_compression_encodings = self.send_compression_encodings;
2613 let max_decoding_message_size = self.max_decoding_message_size;
2614 let max_encoding_message_size = self.max_encoding_message_size;
2615 let inner = self.inner.clone();
2616 let fut = async move {
2617 let inner = inner.0;
2618 let method = WithdrawToBitcoinSvc(inner);
2619 let codec = tonic::codec::ProstCodec::default();
2620 let mut grpc = tonic::server::Grpc::new(codec)
2621 .apply_compression_config(
2622 accept_compression_encodings,
2623 send_compression_encodings,
2624 )
2625 .apply_max_message_size_config(
2626 max_decoding_message_size,
2627 max_encoding_message_size,
2628 );
2629 let res = grpc.unary(method, req).await;
2630 Ok(res)
2631 };
2632 Box::pin(fut)
2633 }
2634 "/side.btcbridge.Msg/SubmitSignatures" => {
2635 #[allow(non_camel_case_types)]
2636 struct SubmitSignaturesSvc<T: Msg>(pub Arc<T>);
2637 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitSignatures> for SubmitSignaturesSvc<T> {
2638 type Response = super::MsgSubmitSignaturesResponse;
2639 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2640 fn call(
2641 &mut self,
2642 request: tonic::Request<super::MsgSubmitSignatures>,
2643 ) -> Self::Future {
2644 let inner = Arc::clone(&self.0);
2645 let fut = async move { (*inner).submit_signatures(request).await };
2646 Box::pin(fut)
2647 }
2648 }
2649 let accept_compression_encodings = self.accept_compression_encodings;
2650 let send_compression_encodings = self.send_compression_encodings;
2651 let max_decoding_message_size = self.max_decoding_message_size;
2652 let max_encoding_message_size = self.max_encoding_message_size;
2653 let inner = self.inner.clone();
2654 let fut = async move {
2655 let inner = inner.0;
2656 let method = SubmitSignaturesSvc(inner);
2657 let codec = tonic::codec::ProstCodec::default();
2658 let mut grpc = tonic::server::Grpc::new(codec)
2659 .apply_compression_config(
2660 accept_compression_encodings,
2661 send_compression_encodings,
2662 )
2663 .apply_max_message_size_config(
2664 max_decoding_message_size,
2665 max_encoding_message_size,
2666 );
2667 let res = grpc.unary(method, req).await;
2668 Ok(res)
2669 };
2670 Box::pin(fut)
2671 }
2672 "/side.btcbridge.Msg/ConsolidateVaults" => {
2673 #[allow(non_camel_case_types)]
2674 struct ConsolidateVaultsSvc<T: Msg>(pub Arc<T>);
2675 impl<T: Msg> tonic::server::UnaryService<super::MsgConsolidateVaults> for ConsolidateVaultsSvc<T> {
2676 type Response = super::MsgConsolidateVaultsResponse;
2677 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2678 fn call(
2679 &mut self,
2680 request: tonic::Request<super::MsgConsolidateVaults>,
2681 ) -> Self::Future {
2682 let inner = Arc::clone(&self.0);
2683 let fut = async move { (*inner).consolidate_vaults(request).await };
2684 Box::pin(fut)
2685 }
2686 }
2687 let accept_compression_encodings = self.accept_compression_encodings;
2688 let send_compression_encodings = self.send_compression_encodings;
2689 let max_decoding_message_size = self.max_decoding_message_size;
2690 let max_encoding_message_size = self.max_encoding_message_size;
2691 let inner = self.inner.clone();
2692 let fut = async move {
2693 let inner = inner.0;
2694 let method = ConsolidateVaultsSvc(inner);
2695 let codec = tonic::codec::ProstCodec::default();
2696 let mut grpc = tonic::server::Grpc::new(codec)
2697 .apply_compression_config(
2698 accept_compression_encodings,
2699 send_compression_encodings,
2700 )
2701 .apply_max_message_size_config(
2702 max_decoding_message_size,
2703 max_encoding_message_size,
2704 );
2705 let res = grpc.unary(method, req).await;
2706 Ok(res)
2707 };
2708 Box::pin(fut)
2709 }
2710 "/side.btcbridge.Msg/InitiateDKG" => {
2711 #[allow(non_camel_case_types)]
2712 struct InitiateDKGSvc<T: Msg>(pub Arc<T>);
2713 impl<T: Msg> tonic::server::UnaryService<super::MsgInitiateDkg> for InitiateDKGSvc<T> {
2714 type Response = super::MsgInitiateDkgResponse;
2715 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2716 fn call(
2717 &mut self,
2718 request: tonic::Request<super::MsgInitiateDkg>,
2719 ) -> Self::Future {
2720 let inner = Arc::clone(&self.0);
2721 let fut = async move { (*inner).initiate_dkg(request).await };
2722 Box::pin(fut)
2723 }
2724 }
2725 let accept_compression_encodings = self.accept_compression_encodings;
2726 let send_compression_encodings = self.send_compression_encodings;
2727 let max_decoding_message_size = self.max_decoding_message_size;
2728 let max_encoding_message_size = self.max_encoding_message_size;
2729 let inner = self.inner.clone();
2730 let fut = async move {
2731 let inner = inner.0;
2732 let method = InitiateDKGSvc(inner);
2733 let codec = tonic::codec::ProstCodec::default();
2734 let mut grpc = tonic::server::Grpc::new(codec)
2735 .apply_compression_config(
2736 accept_compression_encodings,
2737 send_compression_encodings,
2738 )
2739 .apply_max_message_size_config(
2740 max_decoding_message_size,
2741 max_encoding_message_size,
2742 );
2743 let res = grpc.unary(method, req).await;
2744 Ok(res)
2745 };
2746 Box::pin(fut)
2747 }
2748 "/side.btcbridge.Msg/CompleteDKG" => {
2749 #[allow(non_camel_case_types)]
2750 struct CompleteDKGSvc<T: Msg>(pub Arc<T>);
2751 impl<T: Msg> tonic::server::UnaryService<super::MsgCompleteDkg> for CompleteDKGSvc<T> {
2752 type Response = super::MsgCompleteDkgResponse;
2753 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2754 fn call(
2755 &mut self,
2756 request: tonic::Request<super::MsgCompleteDkg>,
2757 ) -> Self::Future {
2758 let inner = Arc::clone(&self.0);
2759 let fut = async move { (*inner).complete_dkg(request).await };
2760 Box::pin(fut)
2761 }
2762 }
2763 let accept_compression_encodings = self.accept_compression_encodings;
2764 let send_compression_encodings = self.send_compression_encodings;
2765 let max_decoding_message_size = self.max_decoding_message_size;
2766 let max_encoding_message_size = self.max_encoding_message_size;
2767 let inner = self.inner.clone();
2768 let fut = async move {
2769 let inner = inner.0;
2770 let method = CompleteDKGSvc(inner);
2771 let codec = tonic::codec::ProstCodec::default();
2772 let mut grpc = tonic::server::Grpc::new(codec)
2773 .apply_compression_config(
2774 accept_compression_encodings,
2775 send_compression_encodings,
2776 )
2777 .apply_max_message_size_config(
2778 max_decoding_message_size,
2779 max_encoding_message_size,
2780 );
2781 let res = grpc.unary(method, req).await;
2782 Ok(res)
2783 };
2784 Box::pin(fut)
2785 }
2786 "/side.btcbridge.Msg/Refresh" => {
2787 #[allow(non_camel_case_types)]
2788 struct RefreshSvc<T: Msg>(pub Arc<T>);
2789 impl<T: Msg> tonic::server::UnaryService<super::MsgRefresh> for RefreshSvc<T> {
2790 type Response = super::MsgRefreshResponse;
2791 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2792 fn call(
2793 &mut self,
2794 request: tonic::Request<super::MsgRefresh>,
2795 ) -> Self::Future {
2796 let inner = Arc::clone(&self.0);
2797 let fut = async move { (*inner).refresh(request).await };
2798 Box::pin(fut)
2799 }
2800 }
2801 let accept_compression_encodings = self.accept_compression_encodings;
2802 let send_compression_encodings = self.send_compression_encodings;
2803 let max_decoding_message_size = self.max_decoding_message_size;
2804 let max_encoding_message_size = self.max_encoding_message_size;
2805 let inner = self.inner.clone();
2806 let fut = async move {
2807 let inner = inner.0;
2808 let method = RefreshSvc(inner);
2809 let codec = tonic::codec::ProstCodec::default();
2810 let mut grpc = tonic::server::Grpc::new(codec)
2811 .apply_compression_config(
2812 accept_compression_encodings,
2813 send_compression_encodings,
2814 )
2815 .apply_max_message_size_config(
2816 max_decoding_message_size,
2817 max_encoding_message_size,
2818 );
2819 let res = grpc.unary(method, req).await;
2820 Ok(res)
2821 };
2822 Box::pin(fut)
2823 }
2824 "/side.btcbridge.Msg/CompleteRefreshing" => {
2825 #[allow(non_camel_case_types)]
2826 struct CompleteRefreshingSvc<T: Msg>(pub Arc<T>);
2827 impl<T: Msg> tonic::server::UnaryService<super::MsgCompleteRefreshing>
2828 for CompleteRefreshingSvc<T>
2829 {
2830 type Response = super::MsgCompleteRefreshingResponse;
2831 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2832 fn call(
2833 &mut self,
2834 request: tonic::Request<super::MsgCompleteRefreshing>,
2835 ) -> Self::Future {
2836 let inner = Arc::clone(&self.0);
2837 let fut = async move { (*inner).complete_refreshing(request).await };
2838 Box::pin(fut)
2839 }
2840 }
2841 let accept_compression_encodings = self.accept_compression_encodings;
2842 let send_compression_encodings = self.send_compression_encodings;
2843 let max_decoding_message_size = self.max_decoding_message_size;
2844 let max_encoding_message_size = self.max_encoding_message_size;
2845 let inner = self.inner.clone();
2846 let fut = async move {
2847 let inner = inner.0;
2848 let method = CompleteRefreshingSvc(inner);
2849 let codec = tonic::codec::ProstCodec::default();
2850 let mut grpc = tonic::server::Grpc::new(codec)
2851 .apply_compression_config(
2852 accept_compression_encodings,
2853 send_compression_encodings,
2854 )
2855 .apply_max_message_size_config(
2856 max_decoding_message_size,
2857 max_encoding_message_size,
2858 );
2859 let res = grpc.unary(method, req).await;
2860 Ok(res)
2861 };
2862 Box::pin(fut)
2863 }
2864 "/side.btcbridge.Msg/TransferVault" => {
2865 #[allow(non_camel_case_types)]
2866 struct TransferVaultSvc<T: Msg>(pub Arc<T>);
2867 impl<T: Msg> tonic::server::UnaryService<super::MsgTransferVault> for TransferVaultSvc<T> {
2868 type Response = super::MsgTransferVaultResponse;
2869 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2870 fn call(
2871 &mut self,
2872 request: tonic::Request<super::MsgTransferVault>,
2873 ) -> Self::Future {
2874 let inner = Arc::clone(&self.0);
2875 let fut = async move { (*inner).transfer_vault(request).await };
2876 Box::pin(fut)
2877 }
2878 }
2879 let accept_compression_encodings = self.accept_compression_encodings;
2880 let send_compression_encodings = self.send_compression_encodings;
2881 let max_decoding_message_size = self.max_decoding_message_size;
2882 let max_encoding_message_size = self.max_encoding_message_size;
2883 let inner = self.inner.clone();
2884 let fut = async move {
2885 let inner = inner.0;
2886 let method = TransferVaultSvc(inner);
2887 let codec = tonic::codec::ProstCodec::default();
2888 let mut grpc = tonic::server::Grpc::new(codec)
2889 .apply_compression_config(
2890 accept_compression_encodings,
2891 send_compression_encodings,
2892 )
2893 .apply_max_message_size_config(
2894 max_decoding_message_size,
2895 max_encoding_message_size,
2896 );
2897 let res = grpc.unary(method, req).await;
2898 Ok(res)
2899 };
2900 Box::pin(fut)
2901 }
2902 "/side.btcbridge.Msg/UpdateParams" => {
2903 #[allow(non_camel_case_types)]
2904 struct UpdateParamsSvc<T: Msg>(pub Arc<T>);
2905 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateParams> for UpdateParamsSvc<T> {
2906 type Response = super::MsgUpdateParamsResponse;
2907 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2908 fn call(
2909 &mut self,
2910 request: tonic::Request<super::MsgUpdateParams>,
2911 ) -> Self::Future {
2912 let inner = Arc::clone(&self.0);
2913 let fut = async move { (*inner).update_params(request).await };
2914 Box::pin(fut)
2915 }
2916 }
2917 let accept_compression_encodings = self.accept_compression_encodings;
2918 let send_compression_encodings = self.send_compression_encodings;
2919 let max_decoding_message_size = self.max_decoding_message_size;
2920 let max_encoding_message_size = self.max_encoding_message_size;
2921 let inner = self.inner.clone();
2922 let fut = async move {
2923 let inner = inner.0;
2924 let method = UpdateParamsSvc(inner);
2925 let codec = tonic::codec::ProstCodec::default();
2926 let mut grpc = tonic::server::Grpc::new(codec)
2927 .apply_compression_config(
2928 accept_compression_encodings,
2929 send_compression_encodings,
2930 )
2931 .apply_max_message_size_config(
2932 max_decoding_message_size,
2933 max_encoding_message_size,
2934 );
2935 let res = grpc.unary(method, req).await;
2936 Ok(res)
2937 };
2938 Box::pin(fut)
2939 }
2940 _ => Box::pin(async move {
2941 Ok(http::Response::builder()
2942 .status(200)
2943 .header("grpc-status", "12")
2944 .header("content-type", "application/grpc")
2945 .body(empty_body())
2946 .unwrap())
2947 }),
2948 }
2949 }
2950 }
2951 impl<T: Msg> Clone for MsgServer<T> {
2952 fn clone(&self) -> Self {
2953 let inner = self.inner.clone();
2954 Self {
2955 inner,
2956 accept_compression_encodings: self.accept_compression_encodings,
2957 send_compression_encodings: self.send_compression_encodings,
2958 max_decoding_message_size: self.max_decoding_message_size,
2959 max_encoding_message_size: self.max_encoding_message_size,
2960 }
2961 }
2962 }
2963 impl<T: Msg> Clone for _Inner<T> {
2964 fn clone(&self) -> Self {
2965 Self(Arc::clone(&self.0))
2966 }
2967 }
2968 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
2969 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2970 write!(f, "{:?}", self.0)
2971 }
2972 }
2973 impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
2974 const NAME: &'static str = "side.btcbridge.Msg";
2975 }
2976}