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 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.lending.Query/Params");
101 let mut req = request.into_request();
102 req.extensions_mut()
103 .insert(GrpcMethod::new("side.lending.Query", "Params"));
104 self.inner.unary(req, path, codec).await
105 }
106 pub async fn pool(
107 &mut self,
108 request: impl tonic::IntoRequest<super::QueryPoolRequest>,
109 ) -> core::result::Result<tonic::Response<super::QueryPoolResponse>, 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.lending.Query/Pool");
119 let mut req = request.into_request();
120 req.extensions_mut()
121 .insert(GrpcMethod::new("side.lending.Query", "Pool"));
122 self.inner.unary(req, path, codec).await
123 }
124 pub async fn pools(
125 &mut self,
126 request: impl tonic::IntoRequest<super::QueryPoolsRequest>,
127 ) -> core::result::Result<tonic::Response<super::QueryPoolsResponse>, tonic::Status>
128 {
129 self.inner.ready().await.map_err(|e| {
130 tonic::Status::new(
131 tonic::Code::Unknown,
132 alloc::format!("Service was not ready: {}", e.into()),
133 )
134 })?;
135 let codec = tonic::codec::ProstCodec::default();
136 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Pools");
137 let mut req = request.into_request();
138 req.extensions_mut()
139 .insert(GrpcMethod::new("side.lending.Query", "Pools"));
140 self.inner.unary(req, path, codec).await
141 }
142 pub async fn collateral_address(
143 &mut self,
144 request: impl tonic::IntoRequest<super::QueryCollateralAddressRequest>,
145 ) -> core::result::Result<
146 tonic::Response<super::QueryCollateralAddressResponse>,
147 tonic::Status,
148 > {
149 self.inner.ready().await.map_err(|e| {
150 tonic::Status::new(
151 tonic::Code::Unknown,
152 alloc::format!("Service was not ready: {}", e.into()),
153 )
154 })?;
155 let codec = tonic::codec::ProstCodec::default();
156 let path =
157 http::uri::PathAndQuery::from_static("/side.lending.Query/CollateralAddress");
158 let mut req = request.into_request();
159 req.extensions_mut()
160 .insert(GrpcMethod::new("side.lending.Query", "CollateralAddress"));
161 self.inner.unary(req, path, codec).await
162 }
163 pub async fn liquidation_event(
164 &mut self,
165 request: impl tonic::IntoRequest<super::QueryLiquidationEventRequest>,
166 ) -> core::result::Result<
167 tonic::Response<super::QueryLiquidationEventResponse>,
168 tonic::Status,
169 > {
170 self.inner.ready().await.map_err(|e| {
171 tonic::Status::new(
172 tonic::Code::Unknown,
173 alloc::format!("Service was not ready: {}", e.into()),
174 )
175 })?;
176 let codec = tonic::codec::ProstCodec::default();
177 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LiquidationEvent");
178 let mut req = request.into_request();
179 req.extensions_mut()
180 .insert(GrpcMethod::new("side.lending.Query", "LiquidationEvent"));
181 self.inner.unary(req, path, codec).await
182 }
183 pub async fn liquidation_cet(
184 &mut self,
185 request: impl tonic::IntoRequest<super::QueryLiquidationCetRequest>,
186 ) -> core::result::Result<tonic::Response<super::QueryLiquidationCetResponse>, tonic::Status>
187 {
188 self.inner.ready().await.map_err(|e| {
189 tonic::Status::new(
190 tonic::Code::Unknown,
191 alloc::format!("Service was not ready: {}", e.into()),
192 )
193 })?;
194 let codec = tonic::codec::ProstCodec::default();
195 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LiquidationCet");
196 let mut req = request.into_request();
197 req.extensions_mut()
198 .insert(GrpcMethod::new("side.lending.Query", "LiquidationCet"));
199 self.inner.unary(req, path, codec).await
200 }
201 pub async fn loan(
202 &mut self,
203 request: impl tonic::IntoRequest<super::QueryLoanRequest>,
204 ) -> core::result::Result<tonic::Response<super::QueryLoanResponse>, tonic::Status>
205 {
206 self.inner.ready().await.map_err(|e| {
207 tonic::Status::new(
208 tonic::Code::Unknown,
209 alloc::format!("Service was not ready: {}", e.into()),
210 )
211 })?;
212 let codec = tonic::codec::ProstCodec::default();
213 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Loan");
214 let mut req = request.into_request();
215 req.extensions_mut()
216 .insert(GrpcMethod::new("side.lending.Query", "Loan"));
217 self.inner.unary(req, path, codec).await
218 }
219 pub async fn loans(
220 &mut self,
221 request: impl tonic::IntoRequest<super::QueryLoansRequest>,
222 ) -> core::result::Result<tonic::Response<super::QueryLoansResponse>, tonic::Status>
223 {
224 self.inner.ready().await.map_err(|e| {
225 tonic::Status::new(
226 tonic::Code::Unknown,
227 alloc::format!("Service was not ready: {}", e.into()),
228 )
229 })?;
230 let codec = tonic::codec::ProstCodec::default();
231 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Loans");
232 let mut req = request.into_request();
233 req.extensions_mut()
234 .insert(GrpcMethod::new("side.lending.Query", "Loans"));
235 self.inner.unary(req, path, codec).await
236 }
237 pub async fn loan_dlc_meta(
238 &mut self,
239 request: impl tonic::IntoRequest<super::QueryLoanDlcMetaRequest>,
240 ) -> core::result::Result<tonic::Response<super::QueryLoanDlcMetaResponse>, tonic::Status>
241 {
242 self.inner.ready().await.map_err(|e| {
243 tonic::Status::new(
244 tonic::Code::Unknown,
245 alloc::format!("Service was not ready: {}", e.into()),
246 )
247 })?;
248 let codec = tonic::codec::ProstCodec::default();
249 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LoanDlcMeta");
250 let mut req = request.into_request();
251 req.extensions_mut()
252 .insert(GrpcMethod::new("side.lending.Query", "LoanDlcMeta"));
253 self.inner.unary(req, path, codec).await
254 }
255 pub async fn repayment(
256 &mut self,
257 request: impl tonic::IntoRequest<super::QueryRepaymentRequest>,
258 ) -> core::result::Result<tonic::Response<super::QueryRepaymentResponse>, tonic::Status>
259 {
260 self.inner.ready().await.map_err(|e| {
261 tonic::Status::new(
262 tonic::Code::Unknown,
263 alloc::format!("Service was not ready: {}", e.into()),
264 )
265 })?;
266 let codec = tonic::codec::ProstCodec::default();
267 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Repayment");
268 let mut req = request.into_request();
269 req.extensions_mut()
270 .insert(GrpcMethod::new("side.lending.Query", "Repayment"));
271 self.inner.unary(req, path, codec).await
272 }
273 }
274}
275#[cfg(feature = "grpc")]
277pub mod query_server {
278 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
279 use tonic::codegen::*;
280 #[async_trait]
282 pub trait Query: Send + Sync + 'static {
283 async fn params(
284 &self,
285 request: tonic::Request<super::QueryParamsRequest>,
286 ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
287 async fn pool(
288 &self,
289 request: tonic::Request<super::QueryPoolRequest>,
290 ) -> core::result::Result<tonic::Response<super::QueryPoolResponse>, tonic::Status>;
291 async fn pools(
292 &self,
293 request: tonic::Request<super::QueryPoolsRequest>,
294 ) -> core::result::Result<tonic::Response<super::QueryPoolsResponse>, tonic::Status>;
295 async fn collateral_address(
296 &self,
297 request: tonic::Request<super::QueryCollateralAddressRequest>,
298 ) -> core::result::Result<
299 tonic::Response<super::QueryCollateralAddressResponse>,
300 tonic::Status,
301 >;
302 async fn liquidation_event(
303 &self,
304 request: tonic::Request<super::QueryLiquidationEventRequest>,
305 ) -> core::result::Result<
306 tonic::Response<super::QueryLiquidationEventResponse>,
307 tonic::Status,
308 >;
309 async fn liquidation_cet(
310 &self,
311 request: tonic::Request<super::QueryLiquidationCetRequest>,
312 ) -> core::result::Result<tonic::Response<super::QueryLiquidationCetResponse>, tonic::Status>;
313 async fn loan(
314 &self,
315 request: tonic::Request<super::QueryLoanRequest>,
316 ) -> core::result::Result<tonic::Response<super::QueryLoanResponse>, tonic::Status>;
317 async fn loans(
318 &self,
319 request: tonic::Request<super::QueryLoansRequest>,
320 ) -> core::result::Result<tonic::Response<super::QueryLoansResponse>, tonic::Status>;
321 async fn loan_dlc_meta(
322 &self,
323 request: tonic::Request<super::QueryLoanDlcMetaRequest>,
324 ) -> core::result::Result<tonic::Response<super::QueryLoanDlcMetaResponse>, tonic::Status>;
325 async fn repayment(
326 &self,
327 request: tonic::Request<super::QueryRepaymentRequest>,
328 ) -> core::result::Result<tonic::Response<super::QueryRepaymentResponse>, tonic::Status>;
329 }
330 #[derive(Debug)]
331 pub struct QueryServer<T: Query> {
332 inner: _Inner<T>,
333 accept_compression_encodings: EnabledCompressionEncodings,
334 send_compression_encodings: EnabledCompressionEncodings,
335 max_decoding_message_size: Option<usize>,
336 max_encoding_message_size: Option<usize>,
337 }
338 struct _Inner<T>(Arc<T>);
339 impl<T: Query> QueryServer<T> {
340 pub fn new(inner: T) -> Self {
341 Self::from_arc(Arc::new(inner))
342 }
343 pub fn from_arc(inner: Arc<T>) -> Self {
344 let inner = _Inner(inner);
345 Self {
346 inner,
347 accept_compression_encodings: Default::default(),
348 send_compression_encodings: Default::default(),
349 max_decoding_message_size: None,
350 max_encoding_message_size: None,
351 }
352 }
353 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
354 where
355 F: tonic::service::Interceptor,
356 {
357 InterceptedService::new(Self::new(inner), interceptor)
358 }
359 #[must_use]
361 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
362 self.accept_compression_encodings.enable(encoding);
363 self
364 }
365 #[must_use]
367 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
368 self.send_compression_encodings.enable(encoding);
369 self
370 }
371 #[must_use]
375 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
376 self.max_decoding_message_size = Some(limit);
377 self
378 }
379 #[must_use]
383 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
384 self.max_encoding_message_size = Some(limit);
385 self
386 }
387 }
388 impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
389 where
390 T: Query,
391 B: Body + Send + 'static,
392 B::Error: Into<StdError> + Send + 'static,
393 {
394 type Response = http::Response<tonic::body::BoxBody>;
395 type Error = std::convert::Infallible;
396 type Future = BoxFuture<Self::Response, Self::Error>;
397 fn poll_ready(
398 &mut self,
399 _cx: &mut Context<'_>,
400 ) -> Poll<core::result::Result<(), Self::Error>> {
401 Poll::Ready(Ok(()))
402 }
403 fn call(&mut self, req: http::Request<B>) -> Self::Future {
404 let inner = self.inner.clone();
405 match req.uri().path() {
406 "/side.lending.Query/Params" => {
407 #[allow(non_camel_case_types)]
408 struct ParamsSvc<T: Query>(pub Arc<T>);
409 impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
410 type Response = super::QueryParamsResponse;
411 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
412 fn call(
413 &mut self,
414 request: tonic::Request<super::QueryParamsRequest>,
415 ) -> Self::Future {
416 let inner = Arc::clone(&self.0);
417 let fut = async move { (*inner).params(request).await };
418 Box::pin(fut)
419 }
420 }
421 let accept_compression_encodings = self.accept_compression_encodings;
422 let send_compression_encodings = self.send_compression_encodings;
423 let max_decoding_message_size = self.max_decoding_message_size;
424 let max_encoding_message_size = self.max_encoding_message_size;
425 let inner = self.inner.clone();
426 let fut = async move {
427 let inner = inner.0;
428 let method = ParamsSvc(inner);
429 let codec = tonic::codec::ProstCodec::default();
430 let mut grpc = tonic::server::Grpc::new(codec)
431 .apply_compression_config(
432 accept_compression_encodings,
433 send_compression_encodings,
434 )
435 .apply_max_message_size_config(
436 max_decoding_message_size,
437 max_encoding_message_size,
438 );
439 let res = grpc.unary(method, req).await;
440 Ok(res)
441 };
442 Box::pin(fut)
443 }
444 "/side.lending.Query/Pool" => {
445 #[allow(non_camel_case_types)]
446 struct PoolSvc<T: Query>(pub Arc<T>);
447 impl<T: Query> tonic::server::UnaryService<super::QueryPoolRequest> for PoolSvc<T> {
448 type Response = super::QueryPoolResponse;
449 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
450 fn call(
451 &mut self,
452 request: tonic::Request<super::QueryPoolRequest>,
453 ) -> Self::Future {
454 let inner = Arc::clone(&self.0);
455 let fut = async move { (*inner).pool(request).await };
456 Box::pin(fut)
457 }
458 }
459 let accept_compression_encodings = self.accept_compression_encodings;
460 let send_compression_encodings = self.send_compression_encodings;
461 let max_decoding_message_size = self.max_decoding_message_size;
462 let max_encoding_message_size = self.max_encoding_message_size;
463 let inner = self.inner.clone();
464 let fut = async move {
465 let inner = inner.0;
466 let method = PoolSvc(inner);
467 let codec = tonic::codec::ProstCodec::default();
468 let mut grpc = tonic::server::Grpc::new(codec)
469 .apply_compression_config(
470 accept_compression_encodings,
471 send_compression_encodings,
472 )
473 .apply_max_message_size_config(
474 max_decoding_message_size,
475 max_encoding_message_size,
476 );
477 let res = grpc.unary(method, req).await;
478 Ok(res)
479 };
480 Box::pin(fut)
481 }
482 "/side.lending.Query/Pools" => {
483 #[allow(non_camel_case_types)]
484 struct PoolsSvc<T: Query>(pub Arc<T>);
485 impl<T: Query> tonic::server::UnaryService<super::QueryPoolsRequest> for PoolsSvc<T> {
486 type Response = super::QueryPoolsResponse;
487 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
488 fn call(
489 &mut self,
490 request: tonic::Request<super::QueryPoolsRequest>,
491 ) -> Self::Future {
492 let inner = Arc::clone(&self.0);
493 let fut = async move { (*inner).pools(request).await };
494 Box::pin(fut)
495 }
496 }
497 let accept_compression_encodings = self.accept_compression_encodings;
498 let send_compression_encodings = self.send_compression_encodings;
499 let max_decoding_message_size = self.max_decoding_message_size;
500 let max_encoding_message_size = self.max_encoding_message_size;
501 let inner = self.inner.clone();
502 let fut = async move {
503 let inner = inner.0;
504 let method = PoolsSvc(inner);
505 let codec = tonic::codec::ProstCodec::default();
506 let mut grpc = tonic::server::Grpc::new(codec)
507 .apply_compression_config(
508 accept_compression_encodings,
509 send_compression_encodings,
510 )
511 .apply_max_message_size_config(
512 max_decoding_message_size,
513 max_encoding_message_size,
514 );
515 let res = grpc.unary(method, req).await;
516 Ok(res)
517 };
518 Box::pin(fut)
519 }
520 "/side.lending.Query/CollateralAddress" => {
521 #[allow(non_camel_case_types)]
522 struct CollateralAddressSvc<T: Query>(pub Arc<T>);
523 impl<T: Query> tonic::server::UnaryService<super::QueryCollateralAddressRequest>
524 for CollateralAddressSvc<T>
525 {
526 type Response = super::QueryCollateralAddressResponse;
527 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
528 fn call(
529 &mut self,
530 request: tonic::Request<super::QueryCollateralAddressRequest>,
531 ) -> Self::Future {
532 let inner = Arc::clone(&self.0);
533 let fut = async move { (*inner).collateral_address(request).await };
534 Box::pin(fut)
535 }
536 }
537 let accept_compression_encodings = self.accept_compression_encodings;
538 let send_compression_encodings = self.send_compression_encodings;
539 let max_decoding_message_size = self.max_decoding_message_size;
540 let max_encoding_message_size = self.max_encoding_message_size;
541 let inner = self.inner.clone();
542 let fut = async move {
543 let inner = inner.0;
544 let method = CollateralAddressSvc(inner);
545 let codec = tonic::codec::ProstCodec::default();
546 let mut grpc = tonic::server::Grpc::new(codec)
547 .apply_compression_config(
548 accept_compression_encodings,
549 send_compression_encodings,
550 )
551 .apply_max_message_size_config(
552 max_decoding_message_size,
553 max_encoding_message_size,
554 );
555 let res = grpc.unary(method, req).await;
556 Ok(res)
557 };
558 Box::pin(fut)
559 }
560 "/side.lending.Query/LiquidationEvent" => {
561 #[allow(non_camel_case_types)]
562 struct LiquidationEventSvc<T: Query>(pub Arc<T>);
563 impl<T: Query> tonic::server::UnaryService<super::QueryLiquidationEventRequest>
564 for LiquidationEventSvc<T>
565 {
566 type Response = super::QueryLiquidationEventResponse;
567 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
568 fn call(
569 &mut self,
570 request: tonic::Request<super::QueryLiquidationEventRequest>,
571 ) -> Self::Future {
572 let inner = Arc::clone(&self.0);
573 let fut = async move { (*inner).liquidation_event(request).await };
574 Box::pin(fut)
575 }
576 }
577 let accept_compression_encodings = self.accept_compression_encodings;
578 let send_compression_encodings = self.send_compression_encodings;
579 let max_decoding_message_size = self.max_decoding_message_size;
580 let max_encoding_message_size = self.max_encoding_message_size;
581 let inner = self.inner.clone();
582 let fut = async move {
583 let inner = inner.0;
584 let method = LiquidationEventSvc(inner);
585 let codec = tonic::codec::ProstCodec::default();
586 let mut grpc = tonic::server::Grpc::new(codec)
587 .apply_compression_config(
588 accept_compression_encodings,
589 send_compression_encodings,
590 )
591 .apply_max_message_size_config(
592 max_decoding_message_size,
593 max_encoding_message_size,
594 );
595 let res = grpc.unary(method, req).await;
596 Ok(res)
597 };
598 Box::pin(fut)
599 }
600 "/side.lending.Query/LiquidationCet" => {
601 #[allow(non_camel_case_types)]
602 struct LiquidationCetSvc<T: Query>(pub Arc<T>);
603 impl<T: Query> tonic::server::UnaryService<super::QueryLiquidationCetRequest>
604 for LiquidationCetSvc<T>
605 {
606 type Response = super::QueryLiquidationCetResponse;
607 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
608 fn call(
609 &mut self,
610 request: tonic::Request<super::QueryLiquidationCetRequest>,
611 ) -> Self::Future {
612 let inner = Arc::clone(&self.0);
613 let fut = async move { (*inner).liquidation_cet(request).await };
614 Box::pin(fut)
615 }
616 }
617 let accept_compression_encodings = self.accept_compression_encodings;
618 let send_compression_encodings = self.send_compression_encodings;
619 let max_decoding_message_size = self.max_decoding_message_size;
620 let max_encoding_message_size = self.max_encoding_message_size;
621 let inner = self.inner.clone();
622 let fut = async move {
623 let inner = inner.0;
624 let method = LiquidationCetSvc(inner);
625 let codec = tonic::codec::ProstCodec::default();
626 let mut grpc = tonic::server::Grpc::new(codec)
627 .apply_compression_config(
628 accept_compression_encodings,
629 send_compression_encodings,
630 )
631 .apply_max_message_size_config(
632 max_decoding_message_size,
633 max_encoding_message_size,
634 );
635 let res = grpc.unary(method, req).await;
636 Ok(res)
637 };
638 Box::pin(fut)
639 }
640 "/side.lending.Query/Loan" => {
641 #[allow(non_camel_case_types)]
642 struct LoanSvc<T: Query>(pub Arc<T>);
643 impl<T: Query> tonic::server::UnaryService<super::QueryLoanRequest> for LoanSvc<T> {
644 type Response = super::QueryLoanResponse;
645 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
646 fn call(
647 &mut self,
648 request: tonic::Request<super::QueryLoanRequest>,
649 ) -> Self::Future {
650 let inner = Arc::clone(&self.0);
651 let fut = async move { (*inner).loan(request).await };
652 Box::pin(fut)
653 }
654 }
655 let accept_compression_encodings = self.accept_compression_encodings;
656 let send_compression_encodings = self.send_compression_encodings;
657 let max_decoding_message_size = self.max_decoding_message_size;
658 let max_encoding_message_size = self.max_encoding_message_size;
659 let inner = self.inner.clone();
660 let fut = async move {
661 let inner = inner.0;
662 let method = LoanSvc(inner);
663 let codec = tonic::codec::ProstCodec::default();
664 let mut grpc = tonic::server::Grpc::new(codec)
665 .apply_compression_config(
666 accept_compression_encodings,
667 send_compression_encodings,
668 )
669 .apply_max_message_size_config(
670 max_decoding_message_size,
671 max_encoding_message_size,
672 );
673 let res = grpc.unary(method, req).await;
674 Ok(res)
675 };
676 Box::pin(fut)
677 }
678 "/side.lending.Query/Loans" => {
679 #[allow(non_camel_case_types)]
680 struct LoansSvc<T: Query>(pub Arc<T>);
681 impl<T: Query> tonic::server::UnaryService<super::QueryLoansRequest> for LoansSvc<T> {
682 type Response = super::QueryLoansResponse;
683 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
684 fn call(
685 &mut self,
686 request: tonic::Request<super::QueryLoansRequest>,
687 ) -> Self::Future {
688 let inner = Arc::clone(&self.0);
689 let fut = async move { (*inner).loans(request).await };
690 Box::pin(fut)
691 }
692 }
693 let accept_compression_encodings = self.accept_compression_encodings;
694 let send_compression_encodings = self.send_compression_encodings;
695 let max_decoding_message_size = self.max_decoding_message_size;
696 let max_encoding_message_size = self.max_encoding_message_size;
697 let inner = self.inner.clone();
698 let fut = async move {
699 let inner = inner.0;
700 let method = LoansSvc(inner);
701 let codec = tonic::codec::ProstCodec::default();
702 let mut grpc = tonic::server::Grpc::new(codec)
703 .apply_compression_config(
704 accept_compression_encodings,
705 send_compression_encodings,
706 )
707 .apply_max_message_size_config(
708 max_decoding_message_size,
709 max_encoding_message_size,
710 );
711 let res = grpc.unary(method, req).await;
712 Ok(res)
713 };
714 Box::pin(fut)
715 }
716 "/side.lending.Query/LoanDlcMeta" => {
717 #[allow(non_camel_case_types)]
718 struct LoanDlcMetaSvc<T: Query>(pub Arc<T>);
719 impl<T: Query> tonic::server::UnaryService<super::QueryLoanDlcMetaRequest> for LoanDlcMetaSvc<T> {
720 type Response = super::QueryLoanDlcMetaResponse;
721 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
722 fn call(
723 &mut self,
724 request: tonic::Request<super::QueryLoanDlcMetaRequest>,
725 ) -> Self::Future {
726 let inner = Arc::clone(&self.0);
727 let fut = async move { (*inner).loan_dlc_meta(request).await };
728 Box::pin(fut)
729 }
730 }
731 let accept_compression_encodings = self.accept_compression_encodings;
732 let send_compression_encodings = self.send_compression_encodings;
733 let max_decoding_message_size = self.max_decoding_message_size;
734 let max_encoding_message_size = self.max_encoding_message_size;
735 let inner = self.inner.clone();
736 let fut = async move {
737 let inner = inner.0;
738 let method = LoanDlcMetaSvc(inner);
739 let codec = tonic::codec::ProstCodec::default();
740 let mut grpc = tonic::server::Grpc::new(codec)
741 .apply_compression_config(
742 accept_compression_encodings,
743 send_compression_encodings,
744 )
745 .apply_max_message_size_config(
746 max_decoding_message_size,
747 max_encoding_message_size,
748 );
749 let res = grpc.unary(method, req).await;
750 Ok(res)
751 };
752 Box::pin(fut)
753 }
754 "/side.lending.Query/Repayment" => {
755 #[allow(non_camel_case_types)]
756 struct RepaymentSvc<T: Query>(pub Arc<T>);
757 impl<T: Query> tonic::server::UnaryService<super::QueryRepaymentRequest> for RepaymentSvc<T> {
758 type Response = super::QueryRepaymentResponse;
759 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
760 fn call(
761 &mut self,
762 request: tonic::Request<super::QueryRepaymentRequest>,
763 ) -> Self::Future {
764 let inner = Arc::clone(&self.0);
765 let fut = async move { (*inner).repayment(request).await };
766 Box::pin(fut)
767 }
768 }
769 let accept_compression_encodings = self.accept_compression_encodings;
770 let send_compression_encodings = self.send_compression_encodings;
771 let max_decoding_message_size = self.max_decoding_message_size;
772 let max_encoding_message_size = self.max_encoding_message_size;
773 let inner = self.inner.clone();
774 let fut = async move {
775 let inner = inner.0;
776 let method = RepaymentSvc(inner);
777 let codec = tonic::codec::ProstCodec::default();
778 let mut grpc = tonic::server::Grpc::new(codec)
779 .apply_compression_config(
780 accept_compression_encodings,
781 send_compression_encodings,
782 )
783 .apply_max_message_size_config(
784 max_decoding_message_size,
785 max_encoding_message_size,
786 );
787 let res = grpc.unary(method, req).await;
788 Ok(res)
789 };
790 Box::pin(fut)
791 }
792 _ => Box::pin(async move {
793 Ok(http::Response::builder()
794 .status(200)
795 .header("grpc-status", "12")
796 .header("content-type", "application/grpc")
797 .body(empty_body())
798 .unwrap())
799 }),
800 }
801 }
802 }
803 impl<T: Query> Clone for QueryServer<T> {
804 fn clone(&self) -> Self {
805 let inner = self.inner.clone();
806 Self {
807 inner,
808 accept_compression_encodings: self.accept_compression_encodings,
809 send_compression_encodings: self.send_compression_encodings,
810 max_decoding_message_size: self.max_decoding_message_size,
811 max_encoding_message_size: self.max_encoding_message_size,
812 }
813 }
814 }
815 impl<T: Query> Clone for _Inner<T> {
816 fn clone(&self) -> Self {
817 Self(Arc::clone(&self.0))
818 }
819 }
820 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
821 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
822 write!(f, "{:?}", self.0)
823 }
824 }
825 impl<T: Query> tonic::server::NamedService for QueryServer<T> {
826 const NAME: &'static str = "side.lending.Query";
827 }
828}
829#[cfg(feature = "grpc")]
831pub mod msg_client {
832 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
833 use tonic::codegen::http::Uri;
834 use tonic::codegen::*;
835 #[derive(Debug, Clone)]
836 pub struct MsgClient<T> {
837 inner: tonic::client::Grpc<T>,
838 }
839 #[cfg(feature = "grpc-transport")]
840 impl MsgClient<tonic::transport::Channel> {
841 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
843 where
844 D: TryInto<tonic::transport::Endpoint>,
845 D::Error: Into<StdError>,
846 {
847 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
848 Ok(Self::new(conn))
849 }
850 }
851 impl<T> MsgClient<T>
852 where
853 T: tonic::client::GrpcService<tonic::body::BoxBody>,
854 T::Error: Into<StdError>,
855 T::ResponseBody: Body<Data = Bytes> + Send + 'static,
856 <T::ResponseBody as Body>::Error: Into<StdError> + Send,
857 {
858 pub fn new(inner: T) -> Self {
859 let inner = tonic::client::Grpc::new(inner);
860 Self { inner }
861 }
862 pub fn with_origin(inner: T, origin: Uri) -> Self {
863 let inner = tonic::client::Grpc::with_origin(inner, origin);
864 Self { inner }
865 }
866 pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
867 where
868 F: tonic::service::Interceptor,
869 T::ResponseBody: Default,
870 T: tonic::codegen::Service<
871 http::Request<tonic::body::BoxBody>,
872 Response = http::Response<
873 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
874 >,
875 >,
876 <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
877 Into<StdError> + Send + Sync,
878 {
879 MsgClient::new(InterceptedService::new(inner, interceptor))
880 }
881 #[must_use]
886 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
887 self.inner = self.inner.send_compressed(encoding);
888 self
889 }
890 #[must_use]
892 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
893 self.inner = self.inner.accept_compressed(encoding);
894 self
895 }
896 #[must_use]
900 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
901 self.inner = self.inner.max_decoding_message_size(limit);
902 self
903 }
904 #[must_use]
908 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
909 self.inner = self.inner.max_encoding_message_size(limit);
910 self
911 }
912 pub async fn create_pool(
913 &mut self,
914 request: impl tonic::IntoRequest<super::MsgCreatePool>,
915 ) -> core::result::Result<tonic::Response<super::MsgCreatePoolResponse>, tonic::Status>
916 {
917 self.inner.ready().await.map_err(|e| {
918 tonic::Status::new(
919 tonic::Code::Unknown,
920 alloc::format!("Service was not ready: {}", e.into()),
921 )
922 })?;
923 let codec = tonic::codec::ProstCodec::default();
924 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/CreatePool");
925 let mut req = request.into_request();
926 req.extensions_mut()
927 .insert(GrpcMethod::new("side.lending.Msg", "CreatePool"));
928 self.inner.unary(req, path, codec).await
929 }
930 pub async fn add_liquidity(
931 &mut self,
932 request: impl tonic::IntoRequest<super::MsgAddLiquidity>,
933 ) -> core::result::Result<tonic::Response<super::MsgAddLiquidityResponse>, tonic::Status>
934 {
935 self.inner.ready().await.map_err(|e| {
936 tonic::Status::new(
937 tonic::Code::Unknown,
938 alloc::format!("Service was not ready: {}", e.into()),
939 )
940 })?;
941 let codec = tonic::codec::ProstCodec::default();
942 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/AddLiquidity");
943 let mut req = request.into_request();
944 req.extensions_mut()
945 .insert(GrpcMethod::new("side.lending.Msg", "AddLiquidity"));
946 self.inner.unary(req, path, codec).await
947 }
948 pub async fn remove_liquidity(
949 &mut self,
950 request: impl tonic::IntoRequest<super::MsgRemoveLiquidity>,
951 ) -> core::result::Result<tonic::Response<super::MsgRemoveLiquidityResponse>, tonic::Status>
952 {
953 self.inner.ready().await.map_err(|e| {
954 tonic::Status::new(
955 tonic::Code::Unknown,
956 alloc::format!("Service was not ready: {}", e.into()),
957 )
958 })?;
959 let codec = tonic::codec::ProstCodec::default();
960 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/RemoveLiquidity");
961 let mut req = request.into_request();
962 req.extensions_mut()
963 .insert(GrpcMethod::new("side.lending.Msg", "RemoveLiquidity"));
964 self.inner.unary(req, path, codec).await
965 }
966 pub async fn apply(
967 &mut self,
968 request: impl tonic::IntoRequest<super::MsgApply>,
969 ) -> core::result::Result<tonic::Response<super::MsgApplyResponse>, tonic::Status> {
970 self.inner.ready().await.map_err(|e| {
971 tonic::Status::new(
972 tonic::Code::Unknown,
973 alloc::format!("Service was not ready: {}", e.into()),
974 )
975 })?;
976 let codec = tonic::codec::ProstCodec::default();
977 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Apply");
978 let mut req = request.into_request();
979 req.extensions_mut()
980 .insert(GrpcMethod::new("side.lending.Msg", "Apply"));
981 self.inner.unary(req, path, codec).await
982 }
983 pub async fn approve(
984 &mut self,
985 request: impl tonic::IntoRequest<super::MsgApprove>,
986 ) -> core::result::Result<tonic::Response<super::MsgApproveResponse>, tonic::Status>
987 {
988 self.inner.ready().await.map_err(|e| {
989 tonic::Status::new(
990 tonic::Code::Unknown,
991 alloc::format!("Service was not ready: {}", e.into()),
992 )
993 })?;
994 let codec = tonic::codec::ProstCodec::default();
995 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Approve");
996 let mut req = request.into_request();
997 req.extensions_mut()
998 .insert(GrpcMethod::new("side.lending.Msg", "Approve"));
999 self.inner.unary(req, path, codec).await
1000 }
1001 pub async fn redeem(
1002 &mut self,
1003 request: impl tonic::IntoRequest<super::MsgRedeem>,
1004 ) -> core::result::Result<tonic::Response<super::MsgRedeemResponse>, tonic::Status>
1005 {
1006 self.inner.ready().await.map_err(|e| {
1007 tonic::Status::new(
1008 tonic::Code::Unknown,
1009 alloc::format!("Service was not ready: {}", e.into()),
1010 )
1011 })?;
1012 let codec = tonic::codec::ProstCodec::default();
1013 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Redeem");
1014 let mut req = request.into_request();
1015 req.extensions_mut()
1016 .insert(GrpcMethod::new("side.lending.Msg", "Redeem"));
1017 self.inner.unary(req, path, codec).await
1018 }
1019 pub async fn repay(
1020 &mut self,
1021 request: impl tonic::IntoRequest<super::MsgRepay>,
1022 ) -> core::result::Result<tonic::Response<super::MsgRepayResponse>, tonic::Status> {
1023 self.inner.ready().await.map_err(|e| {
1024 tonic::Status::new(
1025 tonic::Code::Unknown,
1026 alloc::format!("Service was not ready: {}", e.into()),
1027 )
1028 })?;
1029 let codec = tonic::codec::ProstCodec::default();
1030 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Repay");
1031 let mut req = request.into_request();
1032 req.extensions_mut()
1033 .insert(GrpcMethod::new("side.lending.Msg", "Repay"));
1034 self.inner.unary(req, path, codec).await
1035 }
1036 pub async fn submit_repayment_adaptor_signatures(
1037 &mut self,
1038 request: impl tonic::IntoRequest<super::MsgSubmitRepaymentAdaptorSignatures>,
1039 ) -> core::result::Result<
1040 tonic::Response<super::MsgSubmitRepaymentAdaptorSignaturesResponse>,
1041 tonic::Status,
1042 > {
1043 self.inner.ready().await.map_err(|e| {
1044 tonic::Status::new(
1045 tonic::Code::Unknown,
1046 alloc::format!("Service was not ready: {}", e.into()),
1047 )
1048 })?;
1049 let codec = tonic::codec::ProstCodec::default();
1050 let path = http::uri::PathAndQuery::from_static(
1051 "/side.lending.Msg/SubmitRepaymentAdaptorSignatures",
1052 );
1053 let mut req = request.into_request();
1054 req.extensions_mut().insert(GrpcMethod::new(
1055 "side.lending.Msg",
1056 "SubmitRepaymentAdaptorSignatures",
1057 ));
1058 self.inner.unary(req, path, codec).await
1059 }
1060 pub async fn submit_liquidation_cet_signatures(
1061 &mut self,
1062 request: impl tonic::IntoRequest<super::MsgSubmitLiquidationCetSignatures>,
1063 ) -> core::result::Result<
1064 tonic::Response<super::MsgSubmitLiquidationCetSignaturesResponse>,
1065 tonic::Status,
1066 > {
1067 self.inner.ready().await.map_err(|e| {
1068 tonic::Status::new(
1069 tonic::Code::Unknown,
1070 alloc::format!("Service was not ready: {}", e.into()),
1071 )
1072 })?;
1073 let codec = tonic::codec::ProstCodec::default();
1074 let path = http::uri::PathAndQuery::from_static(
1075 "/side.lending.Msg/SubmitLiquidationCetSignatures",
1076 );
1077 let mut req = request.into_request();
1078 req.extensions_mut().insert(GrpcMethod::new(
1079 "side.lending.Msg",
1080 "SubmitLiquidationCetSignatures",
1081 ));
1082 self.inner.unary(req, path, codec).await
1083 }
1084 pub async fn close(
1085 &mut self,
1086 request: impl tonic::IntoRequest<super::MsgClose>,
1087 ) -> core::result::Result<tonic::Response<super::MsgCloseResponse>, tonic::Status> {
1088 self.inner.ready().await.map_err(|e| {
1089 tonic::Status::new(
1090 tonic::Code::Unknown,
1091 alloc::format!("Service was not ready: {}", e.into()),
1092 )
1093 })?;
1094 let codec = tonic::codec::ProstCodec::default();
1095 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Close");
1096 let mut req = request.into_request();
1097 req.extensions_mut()
1098 .insert(GrpcMethod::new("side.lending.Msg", "Close"));
1099 self.inner.unary(req, path, codec).await
1100 }
1101 pub async fn submit_price(
1102 &mut self,
1103 request: impl tonic::IntoRequest<super::MsgSubmitPrice>,
1104 ) -> core::result::Result<tonic::Response<super::MsgSubmitPriceResponse>, tonic::Status>
1105 {
1106 self.inner.ready().await.map_err(|e| {
1107 tonic::Status::new(
1108 tonic::Code::Unknown,
1109 alloc::format!("Service was not ready: {}", e.into()),
1110 )
1111 })?;
1112 let codec = tonic::codec::ProstCodec::default();
1113 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/SubmitPrice");
1114 let mut req = request.into_request();
1115 req.extensions_mut()
1116 .insert(GrpcMethod::new("side.lending.Msg", "SubmitPrice"));
1117 self.inner.unary(req, path, codec).await
1118 }
1119 pub async fn update_params(
1120 &mut self,
1121 request: impl tonic::IntoRequest<super::MsgUpdateParams>,
1122 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>
1123 {
1124 self.inner.ready().await.map_err(|e| {
1125 tonic::Status::new(
1126 tonic::Code::Unknown,
1127 alloc::format!("Service was not ready: {}", e.into()),
1128 )
1129 })?;
1130 let codec = tonic::codec::ProstCodec::default();
1131 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/UpdateParams");
1132 let mut req = request.into_request();
1133 req.extensions_mut()
1134 .insert(GrpcMethod::new("side.lending.Msg", "UpdateParams"));
1135 self.inner.unary(req, path, codec).await
1136 }
1137 }
1138}
1139#[cfg(feature = "grpc")]
1141pub mod msg_server {
1142 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1143 use tonic::codegen::*;
1144 #[async_trait]
1146 pub trait Msg: Send + Sync + 'static {
1147 async fn create_pool(
1148 &self,
1149 request: tonic::Request<super::MsgCreatePool>,
1150 ) -> core::result::Result<tonic::Response<super::MsgCreatePoolResponse>, tonic::Status>;
1151 async fn add_liquidity(
1152 &self,
1153 request: tonic::Request<super::MsgAddLiquidity>,
1154 ) -> core::result::Result<tonic::Response<super::MsgAddLiquidityResponse>, tonic::Status>;
1155 async fn remove_liquidity(
1156 &self,
1157 request: tonic::Request<super::MsgRemoveLiquidity>,
1158 ) -> core::result::Result<tonic::Response<super::MsgRemoveLiquidityResponse>, tonic::Status>;
1159 async fn apply(
1160 &self,
1161 request: tonic::Request<super::MsgApply>,
1162 ) -> core::result::Result<tonic::Response<super::MsgApplyResponse>, tonic::Status>;
1163 async fn approve(
1164 &self,
1165 request: tonic::Request<super::MsgApprove>,
1166 ) -> core::result::Result<tonic::Response<super::MsgApproveResponse>, tonic::Status>;
1167 async fn redeem(
1168 &self,
1169 request: tonic::Request<super::MsgRedeem>,
1170 ) -> core::result::Result<tonic::Response<super::MsgRedeemResponse>, tonic::Status>;
1171 async fn repay(
1172 &self,
1173 request: tonic::Request<super::MsgRepay>,
1174 ) -> core::result::Result<tonic::Response<super::MsgRepayResponse>, tonic::Status>;
1175 async fn submit_repayment_adaptor_signatures(
1176 &self,
1177 request: tonic::Request<super::MsgSubmitRepaymentAdaptorSignatures>,
1178 ) -> core::result::Result<
1179 tonic::Response<super::MsgSubmitRepaymentAdaptorSignaturesResponse>,
1180 tonic::Status,
1181 >;
1182 async fn submit_liquidation_cet_signatures(
1183 &self,
1184 request: tonic::Request<super::MsgSubmitLiquidationCetSignatures>,
1185 ) -> core::result::Result<
1186 tonic::Response<super::MsgSubmitLiquidationCetSignaturesResponse>,
1187 tonic::Status,
1188 >;
1189 async fn close(
1190 &self,
1191 request: tonic::Request<super::MsgClose>,
1192 ) -> core::result::Result<tonic::Response<super::MsgCloseResponse>, tonic::Status>;
1193 async fn submit_price(
1194 &self,
1195 request: tonic::Request<super::MsgSubmitPrice>,
1196 ) -> core::result::Result<tonic::Response<super::MsgSubmitPriceResponse>, tonic::Status>;
1197 async fn update_params(
1198 &self,
1199 request: tonic::Request<super::MsgUpdateParams>,
1200 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>;
1201 }
1202 #[derive(Debug)]
1203 pub struct MsgServer<T: Msg> {
1204 inner: _Inner<T>,
1205 accept_compression_encodings: EnabledCompressionEncodings,
1206 send_compression_encodings: EnabledCompressionEncodings,
1207 max_decoding_message_size: Option<usize>,
1208 max_encoding_message_size: Option<usize>,
1209 }
1210 struct _Inner<T>(Arc<T>);
1211 impl<T: Msg> MsgServer<T> {
1212 pub fn new(inner: T) -> Self {
1213 Self::from_arc(Arc::new(inner))
1214 }
1215 pub fn from_arc(inner: Arc<T>) -> Self {
1216 let inner = _Inner(inner);
1217 Self {
1218 inner,
1219 accept_compression_encodings: Default::default(),
1220 send_compression_encodings: Default::default(),
1221 max_decoding_message_size: None,
1222 max_encoding_message_size: None,
1223 }
1224 }
1225 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1226 where
1227 F: tonic::service::Interceptor,
1228 {
1229 InterceptedService::new(Self::new(inner), interceptor)
1230 }
1231 #[must_use]
1233 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1234 self.accept_compression_encodings.enable(encoding);
1235 self
1236 }
1237 #[must_use]
1239 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1240 self.send_compression_encodings.enable(encoding);
1241 self
1242 }
1243 #[must_use]
1247 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1248 self.max_decoding_message_size = Some(limit);
1249 self
1250 }
1251 #[must_use]
1255 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1256 self.max_encoding_message_size = Some(limit);
1257 self
1258 }
1259 }
1260 impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
1261 where
1262 T: Msg,
1263 B: Body + Send + 'static,
1264 B::Error: Into<StdError> + Send + 'static,
1265 {
1266 type Response = http::Response<tonic::body::BoxBody>;
1267 type Error = std::convert::Infallible;
1268 type Future = BoxFuture<Self::Response, Self::Error>;
1269 fn poll_ready(
1270 &mut self,
1271 _cx: &mut Context<'_>,
1272 ) -> Poll<core::result::Result<(), Self::Error>> {
1273 Poll::Ready(Ok(()))
1274 }
1275 fn call(&mut self, req: http::Request<B>) -> Self::Future {
1276 let inner = self.inner.clone();
1277 match req.uri().path() {
1278 "/side.lending.Msg/CreatePool" => {
1279 #[allow(non_camel_case_types)]
1280 struct CreatePoolSvc<T: Msg>(pub Arc<T>);
1281 impl<T: Msg> tonic::server::UnaryService<super::MsgCreatePool> for CreatePoolSvc<T> {
1282 type Response = super::MsgCreatePoolResponse;
1283 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1284 fn call(
1285 &mut self,
1286 request: tonic::Request<super::MsgCreatePool>,
1287 ) -> Self::Future {
1288 let inner = Arc::clone(&self.0);
1289 let fut = async move { (*inner).create_pool(request).await };
1290 Box::pin(fut)
1291 }
1292 }
1293 let accept_compression_encodings = self.accept_compression_encodings;
1294 let send_compression_encodings = self.send_compression_encodings;
1295 let max_decoding_message_size = self.max_decoding_message_size;
1296 let max_encoding_message_size = self.max_encoding_message_size;
1297 let inner = self.inner.clone();
1298 let fut = async move {
1299 let inner = inner.0;
1300 let method = CreatePoolSvc(inner);
1301 let codec = tonic::codec::ProstCodec::default();
1302 let mut grpc = tonic::server::Grpc::new(codec)
1303 .apply_compression_config(
1304 accept_compression_encodings,
1305 send_compression_encodings,
1306 )
1307 .apply_max_message_size_config(
1308 max_decoding_message_size,
1309 max_encoding_message_size,
1310 );
1311 let res = grpc.unary(method, req).await;
1312 Ok(res)
1313 };
1314 Box::pin(fut)
1315 }
1316 "/side.lending.Msg/AddLiquidity" => {
1317 #[allow(non_camel_case_types)]
1318 struct AddLiquiditySvc<T: Msg>(pub Arc<T>);
1319 impl<T: Msg> tonic::server::UnaryService<super::MsgAddLiquidity> for AddLiquiditySvc<T> {
1320 type Response = super::MsgAddLiquidityResponse;
1321 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1322 fn call(
1323 &mut self,
1324 request: tonic::Request<super::MsgAddLiquidity>,
1325 ) -> Self::Future {
1326 let inner = Arc::clone(&self.0);
1327 let fut = async move { (*inner).add_liquidity(request).await };
1328 Box::pin(fut)
1329 }
1330 }
1331 let accept_compression_encodings = self.accept_compression_encodings;
1332 let send_compression_encodings = self.send_compression_encodings;
1333 let max_decoding_message_size = self.max_decoding_message_size;
1334 let max_encoding_message_size = self.max_encoding_message_size;
1335 let inner = self.inner.clone();
1336 let fut = async move {
1337 let inner = inner.0;
1338 let method = AddLiquiditySvc(inner);
1339 let codec = tonic::codec::ProstCodec::default();
1340 let mut grpc = tonic::server::Grpc::new(codec)
1341 .apply_compression_config(
1342 accept_compression_encodings,
1343 send_compression_encodings,
1344 )
1345 .apply_max_message_size_config(
1346 max_decoding_message_size,
1347 max_encoding_message_size,
1348 );
1349 let res = grpc.unary(method, req).await;
1350 Ok(res)
1351 };
1352 Box::pin(fut)
1353 }
1354 "/side.lending.Msg/RemoveLiquidity" => {
1355 #[allow(non_camel_case_types)]
1356 struct RemoveLiquiditySvc<T: Msg>(pub Arc<T>);
1357 impl<T: Msg> tonic::server::UnaryService<super::MsgRemoveLiquidity> for RemoveLiquiditySvc<T> {
1358 type Response = super::MsgRemoveLiquidityResponse;
1359 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1360 fn call(
1361 &mut self,
1362 request: tonic::Request<super::MsgRemoveLiquidity>,
1363 ) -> Self::Future {
1364 let inner = Arc::clone(&self.0);
1365 let fut = async move { (*inner).remove_liquidity(request).await };
1366 Box::pin(fut)
1367 }
1368 }
1369 let accept_compression_encodings = self.accept_compression_encodings;
1370 let send_compression_encodings = self.send_compression_encodings;
1371 let max_decoding_message_size = self.max_decoding_message_size;
1372 let max_encoding_message_size = self.max_encoding_message_size;
1373 let inner = self.inner.clone();
1374 let fut = async move {
1375 let inner = inner.0;
1376 let method = RemoveLiquiditySvc(inner);
1377 let codec = tonic::codec::ProstCodec::default();
1378 let mut grpc = tonic::server::Grpc::new(codec)
1379 .apply_compression_config(
1380 accept_compression_encodings,
1381 send_compression_encodings,
1382 )
1383 .apply_max_message_size_config(
1384 max_decoding_message_size,
1385 max_encoding_message_size,
1386 );
1387 let res = grpc.unary(method, req).await;
1388 Ok(res)
1389 };
1390 Box::pin(fut)
1391 }
1392 "/side.lending.Msg/Apply" => {
1393 #[allow(non_camel_case_types)]
1394 struct ApplySvc<T: Msg>(pub Arc<T>);
1395 impl<T: Msg> tonic::server::UnaryService<super::MsgApply> for ApplySvc<T> {
1396 type Response = super::MsgApplyResponse;
1397 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1398 fn call(
1399 &mut self,
1400 request: tonic::Request<super::MsgApply>,
1401 ) -> Self::Future {
1402 let inner = Arc::clone(&self.0);
1403 let fut = async move { (*inner).apply(request).await };
1404 Box::pin(fut)
1405 }
1406 }
1407 let accept_compression_encodings = self.accept_compression_encodings;
1408 let send_compression_encodings = self.send_compression_encodings;
1409 let max_decoding_message_size = self.max_decoding_message_size;
1410 let max_encoding_message_size = self.max_encoding_message_size;
1411 let inner = self.inner.clone();
1412 let fut = async move {
1413 let inner = inner.0;
1414 let method = ApplySvc(inner);
1415 let codec = tonic::codec::ProstCodec::default();
1416 let mut grpc = tonic::server::Grpc::new(codec)
1417 .apply_compression_config(
1418 accept_compression_encodings,
1419 send_compression_encodings,
1420 )
1421 .apply_max_message_size_config(
1422 max_decoding_message_size,
1423 max_encoding_message_size,
1424 );
1425 let res = grpc.unary(method, req).await;
1426 Ok(res)
1427 };
1428 Box::pin(fut)
1429 }
1430 "/side.lending.Msg/Approve" => {
1431 #[allow(non_camel_case_types)]
1432 struct ApproveSvc<T: Msg>(pub Arc<T>);
1433 impl<T: Msg> tonic::server::UnaryService<super::MsgApprove> for ApproveSvc<T> {
1434 type Response = super::MsgApproveResponse;
1435 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1436 fn call(
1437 &mut self,
1438 request: tonic::Request<super::MsgApprove>,
1439 ) -> Self::Future {
1440 let inner = Arc::clone(&self.0);
1441 let fut = async move { (*inner).approve(request).await };
1442 Box::pin(fut)
1443 }
1444 }
1445 let accept_compression_encodings = self.accept_compression_encodings;
1446 let send_compression_encodings = self.send_compression_encodings;
1447 let max_decoding_message_size = self.max_decoding_message_size;
1448 let max_encoding_message_size = self.max_encoding_message_size;
1449 let inner = self.inner.clone();
1450 let fut = async move {
1451 let inner = inner.0;
1452 let method = ApproveSvc(inner);
1453 let codec = tonic::codec::ProstCodec::default();
1454 let mut grpc = tonic::server::Grpc::new(codec)
1455 .apply_compression_config(
1456 accept_compression_encodings,
1457 send_compression_encodings,
1458 )
1459 .apply_max_message_size_config(
1460 max_decoding_message_size,
1461 max_encoding_message_size,
1462 );
1463 let res = grpc.unary(method, req).await;
1464 Ok(res)
1465 };
1466 Box::pin(fut)
1467 }
1468 "/side.lending.Msg/Redeem" => {
1469 #[allow(non_camel_case_types)]
1470 struct RedeemSvc<T: Msg>(pub Arc<T>);
1471 impl<T: Msg> tonic::server::UnaryService<super::MsgRedeem> for RedeemSvc<T> {
1472 type Response = super::MsgRedeemResponse;
1473 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1474 fn call(
1475 &mut self,
1476 request: tonic::Request<super::MsgRedeem>,
1477 ) -> Self::Future {
1478 let inner = Arc::clone(&self.0);
1479 let fut = async move { (*inner).redeem(request).await };
1480 Box::pin(fut)
1481 }
1482 }
1483 let accept_compression_encodings = self.accept_compression_encodings;
1484 let send_compression_encodings = self.send_compression_encodings;
1485 let max_decoding_message_size = self.max_decoding_message_size;
1486 let max_encoding_message_size = self.max_encoding_message_size;
1487 let inner = self.inner.clone();
1488 let fut = async move {
1489 let inner = inner.0;
1490 let method = RedeemSvc(inner);
1491 let codec = tonic::codec::ProstCodec::default();
1492 let mut grpc = tonic::server::Grpc::new(codec)
1493 .apply_compression_config(
1494 accept_compression_encodings,
1495 send_compression_encodings,
1496 )
1497 .apply_max_message_size_config(
1498 max_decoding_message_size,
1499 max_encoding_message_size,
1500 );
1501 let res = grpc.unary(method, req).await;
1502 Ok(res)
1503 };
1504 Box::pin(fut)
1505 }
1506 "/side.lending.Msg/Repay" => {
1507 #[allow(non_camel_case_types)]
1508 struct RepaySvc<T: Msg>(pub Arc<T>);
1509 impl<T: Msg> tonic::server::UnaryService<super::MsgRepay> for RepaySvc<T> {
1510 type Response = super::MsgRepayResponse;
1511 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1512 fn call(
1513 &mut self,
1514 request: tonic::Request<super::MsgRepay>,
1515 ) -> Self::Future {
1516 let inner = Arc::clone(&self.0);
1517 let fut = async move { (*inner).repay(request).await };
1518 Box::pin(fut)
1519 }
1520 }
1521 let accept_compression_encodings = self.accept_compression_encodings;
1522 let send_compression_encodings = self.send_compression_encodings;
1523 let max_decoding_message_size = self.max_decoding_message_size;
1524 let max_encoding_message_size = self.max_encoding_message_size;
1525 let inner = self.inner.clone();
1526 let fut = async move {
1527 let inner = inner.0;
1528 let method = RepaySvc(inner);
1529 let codec = tonic::codec::ProstCodec::default();
1530 let mut grpc = tonic::server::Grpc::new(codec)
1531 .apply_compression_config(
1532 accept_compression_encodings,
1533 send_compression_encodings,
1534 )
1535 .apply_max_message_size_config(
1536 max_decoding_message_size,
1537 max_encoding_message_size,
1538 );
1539 let res = grpc.unary(method, req).await;
1540 Ok(res)
1541 };
1542 Box::pin(fut)
1543 }
1544 "/side.lending.Msg/SubmitRepaymentAdaptorSignatures" => {
1545 #[allow(non_camel_case_types)]
1546 struct SubmitRepaymentAdaptorSignaturesSvc<T: Msg>(pub Arc<T>);
1547 impl<T: Msg>
1548 tonic::server::UnaryService<super::MsgSubmitRepaymentAdaptorSignatures>
1549 for SubmitRepaymentAdaptorSignaturesSvc<T>
1550 {
1551 type Response = super::MsgSubmitRepaymentAdaptorSignaturesResponse;
1552 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1553 fn call(
1554 &mut self,
1555 request: tonic::Request<super::MsgSubmitRepaymentAdaptorSignatures>,
1556 ) -> Self::Future {
1557 let inner = Arc::clone(&self.0);
1558 let fut = async move {
1559 (*inner).submit_repayment_adaptor_signatures(request).await
1560 };
1561 Box::pin(fut)
1562 }
1563 }
1564 let accept_compression_encodings = self.accept_compression_encodings;
1565 let send_compression_encodings = self.send_compression_encodings;
1566 let max_decoding_message_size = self.max_decoding_message_size;
1567 let max_encoding_message_size = self.max_encoding_message_size;
1568 let inner = self.inner.clone();
1569 let fut = async move {
1570 let inner = inner.0;
1571 let method = SubmitRepaymentAdaptorSignaturesSvc(inner);
1572 let codec = tonic::codec::ProstCodec::default();
1573 let mut grpc = tonic::server::Grpc::new(codec)
1574 .apply_compression_config(
1575 accept_compression_encodings,
1576 send_compression_encodings,
1577 )
1578 .apply_max_message_size_config(
1579 max_decoding_message_size,
1580 max_encoding_message_size,
1581 );
1582 let res = grpc.unary(method, req).await;
1583 Ok(res)
1584 };
1585 Box::pin(fut)
1586 }
1587 "/side.lending.Msg/SubmitLiquidationCetSignatures" => {
1588 #[allow(non_camel_case_types)]
1589 struct SubmitLiquidationCetSignaturesSvc<T: Msg>(pub Arc<T>);
1590 impl<T: Msg>
1591 tonic::server::UnaryService<super::MsgSubmitLiquidationCetSignatures>
1592 for SubmitLiquidationCetSignaturesSvc<T>
1593 {
1594 type Response = super::MsgSubmitLiquidationCetSignaturesResponse;
1595 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1596 fn call(
1597 &mut self,
1598 request: tonic::Request<super::MsgSubmitLiquidationCetSignatures>,
1599 ) -> Self::Future {
1600 let inner = Arc::clone(&self.0);
1601 let fut = async move {
1602 (*inner).submit_liquidation_cet_signatures(request).await
1603 };
1604 Box::pin(fut)
1605 }
1606 }
1607 let accept_compression_encodings = self.accept_compression_encodings;
1608 let send_compression_encodings = self.send_compression_encodings;
1609 let max_decoding_message_size = self.max_decoding_message_size;
1610 let max_encoding_message_size = self.max_encoding_message_size;
1611 let inner = self.inner.clone();
1612 let fut = async move {
1613 let inner = inner.0;
1614 let method = SubmitLiquidationCetSignaturesSvc(inner);
1615 let codec = tonic::codec::ProstCodec::default();
1616 let mut grpc = tonic::server::Grpc::new(codec)
1617 .apply_compression_config(
1618 accept_compression_encodings,
1619 send_compression_encodings,
1620 )
1621 .apply_max_message_size_config(
1622 max_decoding_message_size,
1623 max_encoding_message_size,
1624 );
1625 let res = grpc.unary(method, req).await;
1626 Ok(res)
1627 };
1628 Box::pin(fut)
1629 }
1630 "/side.lending.Msg/Close" => {
1631 #[allow(non_camel_case_types)]
1632 struct CloseSvc<T: Msg>(pub Arc<T>);
1633 impl<T: Msg> tonic::server::UnaryService<super::MsgClose> for CloseSvc<T> {
1634 type Response = super::MsgCloseResponse;
1635 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1636 fn call(
1637 &mut self,
1638 request: tonic::Request<super::MsgClose>,
1639 ) -> Self::Future {
1640 let inner = Arc::clone(&self.0);
1641 let fut = async move { (*inner).close(request).await };
1642 Box::pin(fut)
1643 }
1644 }
1645 let accept_compression_encodings = self.accept_compression_encodings;
1646 let send_compression_encodings = self.send_compression_encodings;
1647 let max_decoding_message_size = self.max_decoding_message_size;
1648 let max_encoding_message_size = self.max_encoding_message_size;
1649 let inner = self.inner.clone();
1650 let fut = async move {
1651 let inner = inner.0;
1652 let method = CloseSvc(inner);
1653 let codec = tonic::codec::ProstCodec::default();
1654 let mut grpc = tonic::server::Grpc::new(codec)
1655 .apply_compression_config(
1656 accept_compression_encodings,
1657 send_compression_encodings,
1658 )
1659 .apply_max_message_size_config(
1660 max_decoding_message_size,
1661 max_encoding_message_size,
1662 );
1663 let res = grpc.unary(method, req).await;
1664 Ok(res)
1665 };
1666 Box::pin(fut)
1667 }
1668 "/side.lending.Msg/SubmitPrice" => {
1669 #[allow(non_camel_case_types)]
1670 struct SubmitPriceSvc<T: Msg>(pub Arc<T>);
1671 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitPrice> for SubmitPriceSvc<T> {
1672 type Response = super::MsgSubmitPriceResponse;
1673 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1674 fn call(
1675 &mut self,
1676 request: tonic::Request<super::MsgSubmitPrice>,
1677 ) -> Self::Future {
1678 let inner = Arc::clone(&self.0);
1679 let fut = async move { (*inner).submit_price(request).await };
1680 Box::pin(fut)
1681 }
1682 }
1683 let accept_compression_encodings = self.accept_compression_encodings;
1684 let send_compression_encodings = self.send_compression_encodings;
1685 let max_decoding_message_size = self.max_decoding_message_size;
1686 let max_encoding_message_size = self.max_encoding_message_size;
1687 let inner = self.inner.clone();
1688 let fut = async move {
1689 let inner = inner.0;
1690 let method = SubmitPriceSvc(inner);
1691 let codec = tonic::codec::ProstCodec::default();
1692 let mut grpc = tonic::server::Grpc::new(codec)
1693 .apply_compression_config(
1694 accept_compression_encodings,
1695 send_compression_encodings,
1696 )
1697 .apply_max_message_size_config(
1698 max_decoding_message_size,
1699 max_encoding_message_size,
1700 );
1701 let res = grpc.unary(method, req).await;
1702 Ok(res)
1703 };
1704 Box::pin(fut)
1705 }
1706 "/side.lending.Msg/UpdateParams" => {
1707 #[allow(non_camel_case_types)]
1708 struct UpdateParamsSvc<T: Msg>(pub Arc<T>);
1709 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateParams> for UpdateParamsSvc<T> {
1710 type Response = super::MsgUpdateParamsResponse;
1711 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1712 fn call(
1713 &mut self,
1714 request: tonic::Request<super::MsgUpdateParams>,
1715 ) -> Self::Future {
1716 let inner = Arc::clone(&self.0);
1717 let fut = async move { (*inner).update_params(request).await };
1718 Box::pin(fut)
1719 }
1720 }
1721 let accept_compression_encodings = self.accept_compression_encodings;
1722 let send_compression_encodings = self.send_compression_encodings;
1723 let max_decoding_message_size = self.max_decoding_message_size;
1724 let max_encoding_message_size = self.max_encoding_message_size;
1725 let inner = self.inner.clone();
1726 let fut = async move {
1727 let inner = inner.0;
1728 let method = UpdateParamsSvc(inner);
1729 let codec = tonic::codec::ProstCodec::default();
1730 let mut grpc = tonic::server::Grpc::new(codec)
1731 .apply_compression_config(
1732 accept_compression_encodings,
1733 send_compression_encodings,
1734 )
1735 .apply_max_message_size_config(
1736 max_decoding_message_size,
1737 max_encoding_message_size,
1738 );
1739 let res = grpc.unary(method, req).await;
1740 Ok(res)
1741 };
1742 Box::pin(fut)
1743 }
1744 _ => Box::pin(async move {
1745 Ok(http::Response::builder()
1746 .status(200)
1747 .header("grpc-status", "12")
1748 .header("content-type", "application/grpc")
1749 .body(empty_body())
1750 .unwrap())
1751 }),
1752 }
1753 }
1754 }
1755 impl<T: Msg> Clone for MsgServer<T> {
1756 fn clone(&self) -> Self {
1757 let inner = self.inner.clone();
1758 Self {
1759 inner,
1760 accept_compression_encodings: self.accept_compression_encodings,
1761 send_compression_encodings: self.send_compression_encodings,
1762 max_decoding_message_size: self.max_decoding_message_size,
1763 max_encoding_message_size: self.max_encoding_message_size,
1764 }
1765 }
1766 }
1767 impl<T: Msg> Clone for _Inner<T> {
1768 fn clone(&self) -> Self {
1769 Self(Arc::clone(&self.0))
1770 }
1771 }
1772 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
1773 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1774 write!(f, "{:?}", self.0)
1775 }
1776 }
1777 impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
1778 const NAME: &'static str = "side.lending.Msg";
1779 }
1780}