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 pool_exchange_rate(
143 &mut self,
144 request: impl tonic::IntoRequest<super::QueryPoolExchangeRateRequest>,
145 ) -> core::result::Result<
146 tonic::Response<super::QueryPoolExchangeRateResponse>,
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 = http::uri::PathAndQuery::from_static("/side.lending.Query/PoolExchangeRate");
157 let mut req = request.into_request();
158 req.extensions_mut()
159 .insert(GrpcMethod::new("side.lending.Query", "PoolExchangeRate"));
160 self.inner.unary(req, path, codec).await
161 }
162 pub async fn collateral_address(
163 &mut self,
164 request: impl tonic::IntoRequest<super::QueryCollateralAddressRequest>,
165 ) -> core::result::Result<
166 tonic::Response<super::QueryCollateralAddressResponse>,
167 tonic::Status,
168 > {
169 self.inner.ready().await.map_err(|e| {
170 tonic::Status::new(
171 tonic::Code::Unknown,
172 alloc::format!("Service was not ready: {}", e.into()),
173 )
174 })?;
175 let codec = tonic::codec::ProstCodec::default();
176 let path =
177 http::uri::PathAndQuery::from_static("/side.lending.Query/CollateralAddress");
178 let mut req = request.into_request();
179 req.extensions_mut()
180 .insert(GrpcMethod::new("side.lending.Query", "CollateralAddress"));
181 self.inner.unary(req, path, codec).await
182 }
183 pub async fn liquidation_price(
184 &mut self,
185 request: impl tonic::IntoRequest<super::QueryLiquidationPriceRequest>,
186 ) -> core::result::Result<
187 tonic::Response<super::QueryLiquidationPriceResponse>,
188 tonic::Status,
189 > {
190 self.inner.ready().await.map_err(|e| {
191 tonic::Status::new(
192 tonic::Code::Unknown,
193 alloc::format!("Service was not ready: {}", e.into()),
194 )
195 })?;
196 let codec = tonic::codec::ProstCodec::default();
197 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LiquidationPrice");
198 let mut req = request.into_request();
199 req.extensions_mut()
200 .insert(GrpcMethod::new("side.lending.Query", "LiquidationPrice"));
201 self.inner.unary(req, path, codec).await
202 }
203 pub async fn dlc_event_count(
204 &mut self,
205 request: impl tonic::IntoRequest<super::QueryDlcEventCountRequest>,
206 ) -> core::result::Result<tonic::Response<super::QueryDlcEventCountResponse>, tonic::Status>
207 {
208 self.inner.ready().await.map_err(|e| {
209 tonic::Status::new(
210 tonic::Code::Unknown,
211 alloc::format!("Service was not ready: {}", e.into()),
212 )
213 })?;
214 let codec = tonic::codec::ProstCodec::default();
215 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/DlcEventCount");
216 let mut req = request.into_request();
217 req.extensions_mut()
218 .insert(GrpcMethod::new("side.lending.Query", "DlcEventCount"));
219 self.inner.unary(req, path, codec).await
220 }
221 pub async fn loan(
222 &mut self,
223 request: impl tonic::IntoRequest<super::QueryLoanRequest>,
224 ) -> core::result::Result<tonic::Response<super::QueryLoanResponse>, tonic::Status>
225 {
226 self.inner.ready().await.map_err(|e| {
227 tonic::Status::new(
228 tonic::Code::Unknown,
229 alloc::format!("Service was not ready: {}", e.into()),
230 )
231 })?;
232 let codec = tonic::codec::ProstCodec::default();
233 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Loan");
234 let mut req = request.into_request();
235 req.extensions_mut()
236 .insert(GrpcMethod::new("side.lending.Query", "Loan"));
237 self.inner.unary(req, path, codec).await
238 }
239 pub async fn loans(
240 &mut self,
241 request: impl tonic::IntoRequest<super::QueryLoansRequest>,
242 ) -> core::result::Result<tonic::Response<super::QueryLoansResponse>, tonic::Status>
243 {
244 self.inner.ready().await.map_err(|e| {
245 tonic::Status::new(
246 tonic::Code::Unknown,
247 alloc::format!("Service was not ready: {}", e.into()),
248 )
249 })?;
250 let codec = tonic::codec::ProstCodec::default();
251 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Loans");
252 let mut req = request.into_request();
253 req.extensions_mut()
254 .insert(GrpcMethod::new("side.lending.Query", "Loans"));
255 self.inner.unary(req, path, codec).await
256 }
257 pub async fn loans_by_address(
258 &mut self,
259 request: impl tonic::IntoRequest<super::QueryLoansByAddressRequest>,
260 ) -> core::result::Result<tonic::Response<super::QueryLoansByAddressResponse>, tonic::Status>
261 {
262 self.inner.ready().await.map_err(|e| {
263 tonic::Status::new(
264 tonic::Code::Unknown,
265 alloc::format!("Service was not ready: {}", e.into()),
266 )
267 })?;
268 let codec = tonic::codec::ProstCodec::default();
269 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LoansByAddress");
270 let mut req = request.into_request();
271 req.extensions_mut()
272 .insert(GrpcMethod::new("side.lending.Query", "LoansByAddress"));
273 self.inner.unary(req, path, codec).await
274 }
275 pub async fn loans_by_oracle(
276 &mut self,
277 request: impl tonic::IntoRequest<super::QueryLoansByOracleRequest>,
278 ) -> core::result::Result<tonic::Response<super::QueryLoansByOracleResponse>, tonic::Status>
279 {
280 self.inner.ready().await.map_err(|e| {
281 tonic::Status::new(
282 tonic::Code::Unknown,
283 alloc::format!("Service was not ready: {}", e.into()),
284 )
285 })?;
286 let codec = tonic::codec::ProstCodec::default();
287 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LoansByOracle");
288 let mut req = request.into_request();
289 req.extensions_mut()
290 .insert(GrpcMethod::new("side.lending.Query", "LoansByOracle"));
291 self.inner.unary(req, path, codec).await
292 }
293 pub async fn loan_cet_infos(
294 &mut self,
295 request: impl tonic::IntoRequest<super::QueryLoanCetInfosRequest>,
296 ) -> core::result::Result<tonic::Response<super::QueryLoanCetInfosResponse>, tonic::Status>
297 {
298 self.inner.ready().await.map_err(|e| {
299 tonic::Status::new(
300 tonic::Code::Unknown,
301 alloc::format!("Service was not ready: {}", e.into()),
302 )
303 })?;
304 let codec = tonic::codec::ProstCodec::default();
305 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LoanCetInfos");
306 let mut req = request.into_request();
307 req.extensions_mut()
308 .insert(GrpcMethod::new("side.lending.Query", "LoanCetInfos"));
309 self.inner.unary(req, path, codec).await
310 }
311 pub async fn loan_dlc_meta(
312 &mut self,
313 request: impl tonic::IntoRequest<super::QueryLoanDlcMetaRequest>,
314 ) -> core::result::Result<tonic::Response<super::QueryLoanDlcMetaResponse>, tonic::Status>
315 {
316 self.inner.ready().await.map_err(|e| {
317 tonic::Status::new(
318 tonic::Code::Unknown,
319 alloc::format!("Service was not ready: {}", e.into()),
320 )
321 })?;
322 let codec = tonic::codec::ProstCodec::default();
323 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LoanDlcMeta");
324 let mut req = request.into_request();
325 req.extensions_mut()
326 .insert(GrpcMethod::new("side.lending.Query", "LoanDlcMeta"));
327 self.inner.unary(req, path, codec).await
328 }
329 pub async fn loan_authorization(
330 &mut self,
331 request: impl tonic::IntoRequest<super::QueryLoanAuthorizationRequest>,
332 ) -> core::result::Result<
333 tonic::Response<super::QueryLoanAuthorizationResponse>,
334 tonic::Status,
335 > {
336 self.inner.ready().await.map_err(|e| {
337 tonic::Status::new(
338 tonic::Code::Unknown,
339 alloc::format!("Service was not ready: {}", e.into()),
340 )
341 })?;
342 let codec = tonic::codec::ProstCodec::default();
343 let path =
344 http::uri::PathAndQuery::from_static("/side.lending.Query/LoanAuthorization");
345 let mut req = request.into_request();
346 req.extensions_mut()
347 .insert(GrpcMethod::new("side.lending.Query", "LoanAuthorization"));
348 self.inner.unary(req, path, codec).await
349 }
350 pub async fn loan_deposits(
351 &mut self,
352 request: impl tonic::IntoRequest<super::QueryLoanDepositsRequest>,
353 ) -> core::result::Result<tonic::Response<super::QueryLoanDepositsResponse>, tonic::Status>
354 {
355 self.inner.ready().await.map_err(|e| {
356 tonic::Status::new(
357 tonic::Code::Unknown,
358 alloc::format!("Service was not ready: {}", e.into()),
359 )
360 })?;
361 let codec = tonic::codec::ProstCodec::default();
362 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LoanDeposits");
363 let mut req = request.into_request();
364 req.extensions_mut()
365 .insert(GrpcMethod::new("side.lending.Query", "LoanDeposits"));
366 self.inner.unary(req, path, codec).await
367 }
368 pub async fn redemption(
369 &mut self,
370 request: impl tonic::IntoRequest<super::QueryRedemptionRequest>,
371 ) -> core::result::Result<tonic::Response<super::QueryRedemptionResponse>, tonic::Status>
372 {
373 self.inner.ready().await.map_err(|e| {
374 tonic::Status::new(
375 tonic::Code::Unknown,
376 alloc::format!("Service was not ready: {}", e.into()),
377 )
378 })?;
379 let codec = tonic::codec::ProstCodec::default();
380 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Redemption");
381 let mut req = request.into_request();
382 req.extensions_mut()
383 .insert(GrpcMethod::new("side.lending.Query", "Redemption"));
384 self.inner.unary(req, path, codec).await
385 }
386 pub async fn repayment(
387 &mut self,
388 request: impl tonic::IntoRequest<super::QueryRepaymentRequest>,
389 ) -> core::result::Result<tonic::Response<super::QueryRepaymentResponse>, tonic::Status>
390 {
391 self.inner.ready().await.map_err(|e| {
392 tonic::Status::new(
393 tonic::Code::Unknown,
394 alloc::format!("Service was not ready: {}", e.into()),
395 )
396 })?;
397 let codec = tonic::codec::ProstCodec::default();
398 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Repayment");
399 let mut req = request.into_request();
400 req.extensions_mut()
401 .insert(GrpcMethod::new("side.lending.Query", "Repayment"));
402 self.inner.unary(req, path, codec).await
403 }
404 pub async fn current_interest(
405 &mut self,
406 request: impl tonic::IntoRequest<super::QueryCurrentInterestRequest>,
407 ) -> core::result::Result<tonic::Response<super::QueryCurrentInterestResponse>, tonic::Status>
408 {
409 self.inner.ready().await.map_err(|e| {
410 tonic::Status::new(
411 tonic::Code::Unknown,
412 alloc::format!("Service was not ready: {}", e.into()),
413 )
414 })?;
415 let codec = tonic::codec::ProstCodec::default();
416 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/CurrentInterest");
417 let mut req = request.into_request();
418 req.extensions_mut()
419 .insert(GrpcMethod::new("side.lending.Query", "CurrentInterest"));
420 self.inner.unary(req, path, codec).await
421 }
422 pub async fn referrers(
423 &mut self,
424 request: impl tonic::IntoRequest<super::QueryReferrersRequest>,
425 ) -> core::result::Result<tonic::Response<super::QueryReferrersResponse>, tonic::Status>
426 {
427 self.inner.ready().await.map_err(|e| {
428 tonic::Status::new(
429 tonic::Code::Unknown,
430 alloc::format!("Service was not ready: {}", e.into()),
431 )
432 })?;
433 let codec = tonic::codec::ProstCodec::default();
434 let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Referrers");
435 let mut req = request.into_request();
436 req.extensions_mut()
437 .insert(GrpcMethod::new("side.lending.Query", "Referrers"));
438 self.inner.unary(req, path, codec).await
439 }
440 }
441}
442#[cfg(feature = "grpc")]
444pub mod query_server {
445 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
446 use tonic::codegen::*;
447 #[async_trait]
449 pub trait Query: Send + Sync + 'static {
450 async fn params(
451 &self,
452 request: tonic::Request<super::QueryParamsRequest>,
453 ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
454 async fn pool(
455 &self,
456 request: tonic::Request<super::QueryPoolRequest>,
457 ) -> core::result::Result<tonic::Response<super::QueryPoolResponse>, tonic::Status>;
458 async fn pools(
459 &self,
460 request: tonic::Request<super::QueryPoolsRequest>,
461 ) -> core::result::Result<tonic::Response<super::QueryPoolsResponse>, tonic::Status>;
462 async fn pool_exchange_rate(
463 &self,
464 request: tonic::Request<super::QueryPoolExchangeRateRequest>,
465 ) -> core::result::Result<
466 tonic::Response<super::QueryPoolExchangeRateResponse>,
467 tonic::Status,
468 >;
469 async fn collateral_address(
470 &self,
471 request: tonic::Request<super::QueryCollateralAddressRequest>,
472 ) -> core::result::Result<
473 tonic::Response<super::QueryCollateralAddressResponse>,
474 tonic::Status,
475 >;
476 async fn liquidation_price(
477 &self,
478 request: tonic::Request<super::QueryLiquidationPriceRequest>,
479 ) -> core::result::Result<
480 tonic::Response<super::QueryLiquidationPriceResponse>,
481 tonic::Status,
482 >;
483 async fn dlc_event_count(
484 &self,
485 request: tonic::Request<super::QueryDlcEventCountRequest>,
486 ) -> core::result::Result<tonic::Response<super::QueryDlcEventCountResponse>, tonic::Status>;
487 async fn loan(
488 &self,
489 request: tonic::Request<super::QueryLoanRequest>,
490 ) -> core::result::Result<tonic::Response<super::QueryLoanResponse>, tonic::Status>;
491 async fn loans(
492 &self,
493 request: tonic::Request<super::QueryLoansRequest>,
494 ) -> core::result::Result<tonic::Response<super::QueryLoansResponse>, tonic::Status>;
495 async fn loans_by_address(
496 &self,
497 request: tonic::Request<super::QueryLoansByAddressRequest>,
498 ) -> core::result::Result<tonic::Response<super::QueryLoansByAddressResponse>, tonic::Status>;
499 async fn loans_by_oracle(
500 &self,
501 request: tonic::Request<super::QueryLoansByOracleRequest>,
502 ) -> core::result::Result<tonic::Response<super::QueryLoansByOracleResponse>, tonic::Status>;
503 async fn loan_cet_infos(
504 &self,
505 request: tonic::Request<super::QueryLoanCetInfosRequest>,
506 ) -> core::result::Result<tonic::Response<super::QueryLoanCetInfosResponse>, tonic::Status>;
507 async fn loan_dlc_meta(
508 &self,
509 request: tonic::Request<super::QueryLoanDlcMetaRequest>,
510 ) -> core::result::Result<tonic::Response<super::QueryLoanDlcMetaResponse>, tonic::Status>;
511 async fn loan_authorization(
512 &self,
513 request: tonic::Request<super::QueryLoanAuthorizationRequest>,
514 ) -> core::result::Result<
515 tonic::Response<super::QueryLoanAuthorizationResponse>,
516 tonic::Status,
517 >;
518 async fn loan_deposits(
519 &self,
520 request: tonic::Request<super::QueryLoanDepositsRequest>,
521 ) -> core::result::Result<tonic::Response<super::QueryLoanDepositsResponse>, tonic::Status>;
522 async fn redemption(
523 &self,
524 request: tonic::Request<super::QueryRedemptionRequest>,
525 ) -> core::result::Result<tonic::Response<super::QueryRedemptionResponse>, tonic::Status>;
526 async fn repayment(
527 &self,
528 request: tonic::Request<super::QueryRepaymentRequest>,
529 ) -> core::result::Result<tonic::Response<super::QueryRepaymentResponse>, tonic::Status>;
530 async fn current_interest(
531 &self,
532 request: tonic::Request<super::QueryCurrentInterestRequest>,
533 ) -> core::result::Result<tonic::Response<super::QueryCurrentInterestResponse>, tonic::Status>;
534 async fn referrers(
535 &self,
536 request: tonic::Request<super::QueryReferrersRequest>,
537 ) -> core::result::Result<tonic::Response<super::QueryReferrersResponse>, tonic::Status>;
538 }
539 #[derive(Debug)]
540 pub struct QueryServer<T: Query> {
541 inner: _Inner<T>,
542 accept_compression_encodings: EnabledCompressionEncodings,
543 send_compression_encodings: EnabledCompressionEncodings,
544 max_decoding_message_size: Option<usize>,
545 max_encoding_message_size: Option<usize>,
546 }
547 struct _Inner<T>(Arc<T>);
548 impl<T: Query> QueryServer<T> {
549 pub fn new(inner: T) -> Self {
550 Self::from_arc(Arc::new(inner))
551 }
552 pub fn from_arc(inner: Arc<T>) -> Self {
553 let inner = _Inner(inner);
554 Self {
555 inner,
556 accept_compression_encodings: Default::default(),
557 send_compression_encodings: Default::default(),
558 max_decoding_message_size: None,
559 max_encoding_message_size: None,
560 }
561 }
562 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
563 where
564 F: tonic::service::Interceptor,
565 {
566 InterceptedService::new(Self::new(inner), interceptor)
567 }
568 #[must_use]
570 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
571 self.accept_compression_encodings.enable(encoding);
572 self
573 }
574 #[must_use]
576 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
577 self.send_compression_encodings.enable(encoding);
578 self
579 }
580 #[must_use]
584 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
585 self.max_decoding_message_size = Some(limit);
586 self
587 }
588 #[must_use]
592 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
593 self.max_encoding_message_size = Some(limit);
594 self
595 }
596 }
597 impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
598 where
599 T: Query,
600 B: Body + Send + 'static,
601 B::Error: Into<StdError> + Send + 'static,
602 {
603 type Response = http::Response<tonic::body::BoxBody>;
604 type Error = std::convert::Infallible;
605 type Future = BoxFuture<Self::Response, Self::Error>;
606 fn poll_ready(
607 &mut self,
608 _cx: &mut Context<'_>,
609 ) -> Poll<core::result::Result<(), Self::Error>> {
610 Poll::Ready(Ok(()))
611 }
612 fn call(&mut self, req: http::Request<B>) -> Self::Future {
613 let inner = self.inner.clone();
614 match req.uri().path() {
615 "/side.lending.Query/Params" => {
616 #[allow(non_camel_case_types)]
617 struct ParamsSvc<T: Query>(pub Arc<T>);
618 impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
619 type Response = super::QueryParamsResponse;
620 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
621 fn call(
622 &mut self,
623 request: tonic::Request<super::QueryParamsRequest>,
624 ) -> Self::Future {
625 let inner = Arc::clone(&self.0);
626 let fut = async move { (*inner).params(request).await };
627 Box::pin(fut)
628 }
629 }
630 let accept_compression_encodings = self.accept_compression_encodings;
631 let send_compression_encodings = self.send_compression_encodings;
632 let max_decoding_message_size = self.max_decoding_message_size;
633 let max_encoding_message_size = self.max_encoding_message_size;
634 let inner = self.inner.clone();
635 let fut = async move {
636 let inner = inner.0;
637 let method = ParamsSvc(inner);
638 let codec = tonic::codec::ProstCodec::default();
639 let mut grpc = tonic::server::Grpc::new(codec)
640 .apply_compression_config(
641 accept_compression_encodings,
642 send_compression_encodings,
643 )
644 .apply_max_message_size_config(
645 max_decoding_message_size,
646 max_encoding_message_size,
647 );
648 let res = grpc.unary(method, req).await;
649 Ok(res)
650 };
651 Box::pin(fut)
652 }
653 "/side.lending.Query/Pool" => {
654 #[allow(non_camel_case_types)]
655 struct PoolSvc<T: Query>(pub Arc<T>);
656 impl<T: Query> tonic::server::UnaryService<super::QueryPoolRequest> for PoolSvc<T> {
657 type Response = super::QueryPoolResponse;
658 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
659 fn call(
660 &mut self,
661 request: tonic::Request<super::QueryPoolRequest>,
662 ) -> Self::Future {
663 let inner = Arc::clone(&self.0);
664 let fut = async move { (*inner).pool(request).await };
665 Box::pin(fut)
666 }
667 }
668 let accept_compression_encodings = self.accept_compression_encodings;
669 let send_compression_encodings = self.send_compression_encodings;
670 let max_decoding_message_size = self.max_decoding_message_size;
671 let max_encoding_message_size = self.max_encoding_message_size;
672 let inner = self.inner.clone();
673 let fut = async move {
674 let inner = inner.0;
675 let method = PoolSvc(inner);
676 let codec = tonic::codec::ProstCodec::default();
677 let mut grpc = tonic::server::Grpc::new(codec)
678 .apply_compression_config(
679 accept_compression_encodings,
680 send_compression_encodings,
681 )
682 .apply_max_message_size_config(
683 max_decoding_message_size,
684 max_encoding_message_size,
685 );
686 let res = grpc.unary(method, req).await;
687 Ok(res)
688 };
689 Box::pin(fut)
690 }
691 "/side.lending.Query/Pools" => {
692 #[allow(non_camel_case_types)]
693 struct PoolsSvc<T: Query>(pub Arc<T>);
694 impl<T: Query> tonic::server::UnaryService<super::QueryPoolsRequest> for PoolsSvc<T> {
695 type Response = super::QueryPoolsResponse;
696 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
697 fn call(
698 &mut self,
699 request: tonic::Request<super::QueryPoolsRequest>,
700 ) -> Self::Future {
701 let inner = Arc::clone(&self.0);
702 let fut = async move { (*inner).pools(request).await };
703 Box::pin(fut)
704 }
705 }
706 let accept_compression_encodings = self.accept_compression_encodings;
707 let send_compression_encodings = self.send_compression_encodings;
708 let max_decoding_message_size = self.max_decoding_message_size;
709 let max_encoding_message_size = self.max_encoding_message_size;
710 let inner = self.inner.clone();
711 let fut = async move {
712 let inner = inner.0;
713 let method = PoolsSvc(inner);
714 let codec = tonic::codec::ProstCodec::default();
715 let mut grpc = tonic::server::Grpc::new(codec)
716 .apply_compression_config(
717 accept_compression_encodings,
718 send_compression_encodings,
719 )
720 .apply_max_message_size_config(
721 max_decoding_message_size,
722 max_encoding_message_size,
723 );
724 let res = grpc.unary(method, req).await;
725 Ok(res)
726 };
727 Box::pin(fut)
728 }
729 "/side.lending.Query/PoolExchangeRate" => {
730 #[allow(non_camel_case_types)]
731 struct PoolExchangeRateSvc<T: Query>(pub Arc<T>);
732 impl<T: Query> tonic::server::UnaryService<super::QueryPoolExchangeRateRequest>
733 for PoolExchangeRateSvc<T>
734 {
735 type Response = super::QueryPoolExchangeRateResponse;
736 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
737 fn call(
738 &mut self,
739 request: tonic::Request<super::QueryPoolExchangeRateRequest>,
740 ) -> Self::Future {
741 let inner = Arc::clone(&self.0);
742 let fut = async move { (*inner).pool_exchange_rate(request).await };
743 Box::pin(fut)
744 }
745 }
746 let accept_compression_encodings = self.accept_compression_encodings;
747 let send_compression_encodings = self.send_compression_encodings;
748 let max_decoding_message_size = self.max_decoding_message_size;
749 let max_encoding_message_size = self.max_encoding_message_size;
750 let inner = self.inner.clone();
751 let fut = async move {
752 let inner = inner.0;
753 let method = PoolExchangeRateSvc(inner);
754 let codec = tonic::codec::ProstCodec::default();
755 let mut grpc = tonic::server::Grpc::new(codec)
756 .apply_compression_config(
757 accept_compression_encodings,
758 send_compression_encodings,
759 )
760 .apply_max_message_size_config(
761 max_decoding_message_size,
762 max_encoding_message_size,
763 );
764 let res = grpc.unary(method, req).await;
765 Ok(res)
766 };
767 Box::pin(fut)
768 }
769 "/side.lending.Query/CollateralAddress" => {
770 #[allow(non_camel_case_types)]
771 struct CollateralAddressSvc<T: Query>(pub Arc<T>);
772 impl<T: Query> tonic::server::UnaryService<super::QueryCollateralAddressRequest>
773 for CollateralAddressSvc<T>
774 {
775 type Response = super::QueryCollateralAddressResponse;
776 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
777 fn call(
778 &mut self,
779 request: tonic::Request<super::QueryCollateralAddressRequest>,
780 ) -> Self::Future {
781 let inner = Arc::clone(&self.0);
782 let fut = async move { (*inner).collateral_address(request).await };
783 Box::pin(fut)
784 }
785 }
786 let accept_compression_encodings = self.accept_compression_encodings;
787 let send_compression_encodings = self.send_compression_encodings;
788 let max_decoding_message_size = self.max_decoding_message_size;
789 let max_encoding_message_size = self.max_encoding_message_size;
790 let inner = self.inner.clone();
791 let fut = async move {
792 let inner = inner.0;
793 let method = CollateralAddressSvc(inner);
794 let codec = tonic::codec::ProstCodec::default();
795 let mut grpc = tonic::server::Grpc::new(codec)
796 .apply_compression_config(
797 accept_compression_encodings,
798 send_compression_encodings,
799 )
800 .apply_max_message_size_config(
801 max_decoding_message_size,
802 max_encoding_message_size,
803 );
804 let res = grpc.unary(method, req).await;
805 Ok(res)
806 };
807 Box::pin(fut)
808 }
809 "/side.lending.Query/LiquidationPrice" => {
810 #[allow(non_camel_case_types)]
811 struct LiquidationPriceSvc<T: Query>(pub Arc<T>);
812 impl<T: Query> tonic::server::UnaryService<super::QueryLiquidationPriceRequest>
813 for LiquidationPriceSvc<T>
814 {
815 type Response = super::QueryLiquidationPriceResponse;
816 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
817 fn call(
818 &mut self,
819 request: tonic::Request<super::QueryLiquidationPriceRequest>,
820 ) -> Self::Future {
821 let inner = Arc::clone(&self.0);
822 let fut = async move { (*inner).liquidation_price(request).await };
823 Box::pin(fut)
824 }
825 }
826 let accept_compression_encodings = self.accept_compression_encodings;
827 let send_compression_encodings = self.send_compression_encodings;
828 let max_decoding_message_size = self.max_decoding_message_size;
829 let max_encoding_message_size = self.max_encoding_message_size;
830 let inner = self.inner.clone();
831 let fut = async move {
832 let inner = inner.0;
833 let method = LiquidationPriceSvc(inner);
834 let codec = tonic::codec::ProstCodec::default();
835 let mut grpc = tonic::server::Grpc::new(codec)
836 .apply_compression_config(
837 accept_compression_encodings,
838 send_compression_encodings,
839 )
840 .apply_max_message_size_config(
841 max_decoding_message_size,
842 max_encoding_message_size,
843 );
844 let res = grpc.unary(method, req).await;
845 Ok(res)
846 };
847 Box::pin(fut)
848 }
849 "/side.lending.Query/DlcEventCount" => {
850 #[allow(non_camel_case_types)]
851 struct DlcEventCountSvc<T: Query>(pub Arc<T>);
852 impl<T: Query> tonic::server::UnaryService<super::QueryDlcEventCountRequest>
853 for DlcEventCountSvc<T>
854 {
855 type Response = super::QueryDlcEventCountResponse;
856 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
857 fn call(
858 &mut self,
859 request: tonic::Request<super::QueryDlcEventCountRequest>,
860 ) -> Self::Future {
861 let inner = Arc::clone(&self.0);
862 let fut = async move { (*inner).dlc_event_count(request).await };
863 Box::pin(fut)
864 }
865 }
866 let accept_compression_encodings = self.accept_compression_encodings;
867 let send_compression_encodings = self.send_compression_encodings;
868 let max_decoding_message_size = self.max_decoding_message_size;
869 let max_encoding_message_size = self.max_encoding_message_size;
870 let inner = self.inner.clone();
871 let fut = async move {
872 let inner = inner.0;
873 let method = DlcEventCountSvc(inner);
874 let codec = tonic::codec::ProstCodec::default();
875 let mut grpc = tonic::server::Grpc::new(codec)
876 .apply_compression_config(
877 accept_compression_encodings,
878 send_compression_encodings,
879 )
880 .apply_max_message_size_config(
881 max_decoding_message_size,
882 max_encoding_message_size,
883 );
884 let res = grpc.unary(method, req).await;
885 Ok(res)
886 };
887 Box::pin(fut)
888 }
889 "/side.lending.Query/Loan" => {
890 #[allow(non_camel_case_types)]
891 struct LoanSvc<T: Query>(pub Arc<T>);
892 impl<T: Query> tonic::server::UnaryService<super::QueryLoanRequest> for LoanSvc<T> {
893 type Response = super::QueryLoanResponse;
894 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
895 fn call(
896 &mut self,
897 request: tonic::Request<super::QueryLoanRequest>,
898 ) -> Self::Future {
899 let inner = Arc::clone(&self.0);
900 let fut = async move { (*inner).loan(request).await };
901 Box::pin(fut)
902 }
903 }
904 let accept_compression_encodings = self.accept_compression_encodings;
905 let send_compression_encodings = self.send_compression_encodings;
906 let max_decoding_message_size = self.max_decoding_message_size;
907 let max_encoding_message_size = self.max_encoding_message_size;
908 let inner = self.inner.clone();
909 let fut = async move {
910 let inner = inner.0;
911 let method = LoanSvc(inner);
912 let codec = tonic::codec::ProstCodec::default();
913 let mut grpc = tonic::server::Grpc::new(codec)
914 .apply_compression_config(
915 accept_compression_encodings,
916 send_compression_encodings,
917 )
918 .apply_max_message_size_config(
919 max_decoding_message_size,
920 max_encoding_message_size,
921 );
922 let res = grpc.unary(method, req).await;
923 Ok(res)
924 };
925 Box::pin(fut)
926 }
927 "/side.lending.Query/Loans" => {
928 #[allow(non_camel_case_types)]
929 struct LoansSvc<T: Query>(pub Arc<T>);
930 impl<T: Query> tonic::server::UnaryService<super::QueryLoansRequest> for LoansSvc<T> {
931 type Response = super::QueryLoansResponse;
932 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
933 fn call(
934 &mut self,
935 request: tonic::Request<super::QueryLoansRequest>,
936 ) -> Self::Future {
937 let inner = Arc::clone(&self.0);
938 let fut = async move { (*inner).loans(request).await };
939 Box::pin(fut)
940 }
941 }
942 let accept_compression_encodings = self.accept_compression_encodings;
943 let send_compression_encodings = self.send_compression_encodings;
944 let max_decoding_message_size = self.max_decoding_message_size;
945 let max_encoding_message_size = self.max_encoding_message_size;
946 let inner = self.inner.clone();
947 let fut = async move {
948 let inner = inner.0;
949 let method = LoansSvc(inner);
950 let codec = tonic::codec::ProstCodec::default();
951 let mut grpc = tonic::server::Grpc::new(codec)
952 .apply_compression_config(
953 accept_compression_encodings,
954 send_compression_encodings,
955 )
956 .apply_max_message_size_config(
957 max_decoding_message_size,
958 max_encoding_message_size,
959 );
960 let res = grpc.unary(method, req).await;
961 Ok(res)
962 };
963 Box::pin(fut)
964 }
965 "/side.lending.Query/LoansByAddress" => {
966 #[allow(non_camel_case_types)]
967 struct LoansByAddressSvc<T: Query>(pub Arc<T>);
968 impl<T: Query> tonic::server::UnaryService<super::QueryLoansByAddressRequest>
969 for LoansByAddressSvc<T>
970 {
971 type Response = super::QueryLoansByAddressResponse;
972 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
973 fn call(
974 &mut self,
975 request: tonic::Request<super::QueryLoansByAddressRequest>,
976 ) -> Self::Future {
977 let inner = Arc::clone(&self.0);
978 let fut = async move { (*inner).loans_by_address(request).await };
979 Box::pin(fut)
980 }
981 }
982 let accept_compression_encodings = self.accept_compression_encodings;
983 let send_compression_encodings = self.send_compression_encodings;
984 let max_decoding_message_size = self.max_decoding_message_size;
985 let max_encoding_message_size = self.max_encoding_message_size;
986 let inner = self.inner.clone();
987 let fut = async move {
988 let inner = inner.0;
989 let method = LoansByAddressSvc(inner);
990 let codec = tonic::codec::ProstCodec::default();
991 let mut grpc = tonic::server::Grpc::new(codec)
992 .apply_compression_config(
993 accept_compression_encodings,
994 send_compression_encodings,
995 )
996 .apply_max_message_size_config(
997 max_decoding_message_size,
998 max_encoding_message_size,
999 );
1000 let res = grpc.unary(method, req).await;
1001 Ok(res)
1002 };
1003 Box::pin(fut)
1004 }
1005 "/side.lending.Query/LoansByOracle" => {
1006 #[allow(non_camel_case_types)]
1007 struct LoansByOracleSvc<T: Query>(pub Arc<T>);
1008 impl<T: Query> tonic::server::UnaryService<super::QueryLoansByOracleRequest>
1009 for LoansByOracleSvc<T>
1010 {
1011 type Response = super::QueryLoansByOracleResponse;
1012 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1013 fn call(
1014 &mut self,
1015 request: tonic::Request<super::QueryLoansByOracleRequest>,
1016 ) -> Self::Future {
1017 let inner = Arc::clone(&self.0);
1018 let fut = async move { (*inner).loans_by_oracle(request).await };
1019 Box::pin(fut)
1020 }
1021 }
1022 let accept_compression_encodings = self.accept_compression_encodings;
1023 let send_compression_encodings = self.send_compression_encodings;
1024 let max_decoding_message_size = self.max_decoding_message_size;
1025 let max_encoding_message_size = self.max_encoding_message_size;
1026 let inner = self.inner.clone();
1027 let fut = async move {
1028 let inner = inner.0;
1029 let method = LoansByOracleSvc(inner);
1030 let codec = tonic::codec::ProstCodec::default();
1031 let mut grpc = tonic::server::Grpc::new(codec)
1032 .apply_compression_config(
1033 accept_compression_encodings,
1034 send_compression_encodings,
1035 )
1036 .apply_max_message_size_config(
1037 max_decoding_message_size,
1038 max_encoding_message_size,
1039 );
1040 let res = grpc.unary(method, req).await;
1041 Ok(res)
1042 };
1043 Box::pin(fut)
1044 }
1045 "/side.lending.Query/LoanCetInfos" => {
1046 #[allow(non_camel_case_types)]
1047 struct LoanCetInfosSvc<T: Query>(pub Arc<T>);
1048 impl<T: Query> tonic::server::UnaryService<super::QueryLoanCetInfosRequest> for LoanCetInfosSvc<T> {
1049 type Response = super::QueryLoanCetInfosResponse;
1050 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1051 fn call(
1052 &mut self,
1053 request: tonic::Request<super::QueryLoanCetInfosRequest>,
1054 ) -> Self::Future {
1055 let inner = Arc::clone(&self.0);
1056 let fut = async move { (*inner).loan_cet_infos(request).await };
1057 Box::pin(fut)
1058 }
1059 }
1060 let accept_compression_encodings = self.accept_compression_encodings;
1061 let send_compression_encodings = self.send_compression_encodings;
1062 let max_decoding_message_size = self.max_decoding_message_size;
1063 let max_encoding_message_size = self.max_encoding_message_size;
1064 let inner = self.inner.clone();
1065 let fut = async move {
1066 let inner = inner.0;
1067 let method = LoanCetInfosSvc(inner);
1068 let codec = tonic::codec::ProstCodec::default();
1069 let mut grpc = tonic::server::Grpc::new(codec)
1070 .apply_compression_config(
1071 accept_compression_encodings,
1072 send_compression_encodings,
1073 )
1074 .apply_max_message_size_config(
1075 max_decoding_message_size,
1076 max_encoding_message_size,
1077 );
1078 let res = grpc.unary(method, req).await;
1079 Ok(res)
1080 };
1081 Box::pin(fut)
1082 }
1083 "/side.lending.Query/LoanDlcMeta" => {
1084 #[allow(non_camel_case_types)]
1085 struct LoanDlcMetaSvc<T: Query>(pub Arc<T>);
1086 impl<T: Query> tonic::server::UnaryService<super::QueryLoanDlcMetaRequest> for LoanDlcMetaSvc<T> {
1087 type Response = super::QueryLoanDlcMetaResponse;
1088 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1089 fn call(
1090 &mut self,
1091 request: tonic::Request<super::QueryLoanDlcMetaRequest>,
1092 ) -> Self::Future {
1093 let inner = Arc::clone(&self.0);
1094 let fut = async move { (*inner).loan_dlc_meta(request).await };
1095 Box::pin(fut)
1096 }
1097 }
1098 let accept_compression_encodings = self.accept_compression_encodings;
1099 let send_compression_encodings = self.send_compression_encodings;
1100 let max_decoding_message_size = self.max_decoding_message_size;
1101 let max_encoding_message_size = self.max_encoding_message_size;
1102 let inner = self.inner.clone();
1103 let fut = async move {
1104 let inner = inner.0;
1105 let method = LoanDlcMetaSvc(inner);
1106 let codec = tonic::codec::ProstCodec::default();
1107 let mut grpc = tonic::server::Grpc::new(codec)
1108 .apply_compression_config(
1109 accept_compression_encodings,
1110 send_compression_encodings,
1111 )
1112 .apply_max_message_size_config(
1113 max_decoding_message_size,
1114 max_encoding_message_size,
1115 );
1116 let res = grpc.unary(method, req).await;
1117 Ok(res)
1118 };
1119 Box::pin(fut)
1120 }
1121 "/side.lending.Query/LoanAuthorization" => {
1122 #[allow(non_camel_case_types)]
1123 struct LoanAuthorizationSvc<T: Query>(pub Arc<T>);
1124 impl<T: Query> tonic::server::UnaryService<super::QueryLoanAuthorizationRequest>
1125 for LoanAuthorizationSvc<T>
1126 {
1127 type Response = super::QueryLoanAuthorizationResponse;
1128 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1129 fn call(
1130 &mut self,
1131 request: tonic::Request<super::QueryLoanAuthorizationRequest>,
1132 ) -> Self::Future {
1133 let inner = Arc::clone(&self.0);
1134 let fut = async move { (*inner).loan_authorization(request).await };
1135 Box::pin(fut)
1136 }
1137 }
1138 let accept_compression_encodings = self.accept_compression_encodings;
1139 let send_compression_encodings = self.send_compression_encodings;
1140 let max_decoding_message_size = self.max_decoding_message_size;
1141 let max_encoding_message_size = self.max_encoding_message_size;
1142 let inner = self.inner.clone();
1143 let fut = async move {
1144 let inner = inner.0;
1145 let method = LoanAuthorizationSvc(inner);
1146 let codec = tonic::codec::ProstCodec::default();
1147 let mut grpc = tonic::server::Grpc::new(codec)
1148 .apply_compression_config(
1149 accept_compression_encodings,
1150 send_compression_encodings,
1151 )
1152 .apply_max_message_size_config(
1153 max_decoding_message_size,
1154 max_encoding_message_size,
1155 );
1156 let res = grpc.unary(method, req).await;
1157 Ok(res)
1158 };
1159 Box::pin(fut)
1160 }
1161 "/side.lending.Query/LoanDeposits" => {
1162 #[allow(non_camel_case_types)]
1163 struct LoanDepositsSvc<T: Query>(pub Arc<T>);
1164 impl<T: Query> tonic::server::UnaryService<super::QueryLoanDepositsRequest> for LoanDepositsSvc<T> {
1165 type Response = super::QueryLoanDepositsResponse;
1166 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1167 fn call(
1168 &mut self,
1169 request: tonic::Request<super::QueryLoanDepositsRequest>,
1170 ) -> Self::Future {
1171 let inner = Arc::clone(&self.0);
1172 let fut = async move { (*inner).loan_deposits(request).await };
1173 Box::pin(fut)
1174 }
1175 }
1176 let accept_compression_encodings = self.accept_compression_encodings;
1177 let send_compression_encodings = self.send_compression_encodings;
1178 let max_decoding_message_size = self.max_decoding_message_size;
1179 let max_encoding_message_size = self.max_encoding_message_size;
1180 let inner = self.inner.clone();
1181 let fut = async move {
1182 let inner = inner.0;
1183 let method = LoanDepositsSvc(inner);
1184 let codec = tonic::codec::ProstCodec::default();
1185 let mut grpc = tonic::server::Grpc::new(codec)
1186 .apply_compression_config(
1187 accept_compression_encodings,
1188 send_compression_encodings,
1189 )
1190 .apply_max_message_size_config(
1191 max_decoding_message_size,
1192 max_encoding_message_size,
1193 );
1194 let res = grpc.unary(method, req).await;
1195 Ok(res)
1196 };
1197 Box::pin(fut)
1198 }
1199 "/side.lending.Query/Redemption" => {
1200 #[allow(non_camel_case_types)]
1201 struct RedemptionSvc<T: Query>(pub Arc<T>);
1202 impl<T: Query> tonic::server::UnaryService<super::QueryRedemptionRequest> for RedemptionSvc<T> {
1203 type Response = super::QueryRedemptionResponse;
1204 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1205 fn call(
1206 &mut self,
1207 request: tonic::Request<super::QueryRedemptionRequest>,
1208 ) -> Self::Future {
1209 let inner = Arc::clone(&self.0);
1210 let fut = async move { (*inner).redemption(request).await };
1211 Box::pin(fut)
1212 }
1213 }
1214 let accept_compression_encodings = self.accept_compression_encodings;
1215 let send_compression_encodings = self.send_compression_encodings;
1216 let max_decoding_message_size = self.max_decoding_message_size;
1217 let max_encoding_message_size = self.max_encoding_message_size;
1218 let inner = self.inner.clone();
1219 let fut = async move {
1220 let inner = inner.0;
1221 let method = RedemptionSvc(inner);
1222 let codec = tonic::codec::ProstCodec::default();
1223 let mut grpc = tonic::server::Grpc::new(codec)
1224 .apply_compression_config(
1225 accept_compression_encodings,
1226 send_compression_encodings,
1227 )
1228 .apply_max_message_size_config(
1229 max_decoding_message_size,
1230 max_encoding_message_size,
1231 );
1232 let res = grpc.unary(method, req).await;
1233 Ok(res)
1234 };
1235 Box::pin(fut)
1236 }
1237 "/side.lending.Query/Repayment" => {
1238 #[allow(non_camel_case_types)]
1239 struct RepaymentSvc<T: Query>(pub Arc<T>);
1240 impl<T: Query> tonic::server::UnaryService<super::QueryRepaymentRequest> for RepaymentSvc<T> {
1241 type Response = super::QueryRepaymentResponse;
1242 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1243 fn call(
1244 &mut self,
1245 request: tonic::Request<super::QueryRepaymentRequest>,
1246 ) -> Self::Future {
1247 let inner = Arc::clone(&self.0);
1248 let fut = async move { (*inner).repayment(request).await };
1249 Box::pin(fut)
1250 }
1251 }
1252 let accept_compression_encodings = self.accept_compression_encodings;
1253 let send_compression_encodings = self.send_compression_encodings;
1254 let max_decoding_message_size = self.max_decoding_message_size;
1255 let max_encoding_message_size = self.max_encoding_message_size;
1256 let inner = self.inner.clone();
1257 let fut = async move {
1258 let inner = inner.0;
1259 let method = RepaymentSvc(inner);
1260 let codec = tonic::codec::ProstCodec::default();
1261 let mut grpc = tonic::server::Grpc::new(codec)
1262 .apply_compression_config(
1263 accept_compression_encodings,
1264 send_compression_encodings,
1265 )
1266 .apply_max_message_size_config(
1267 max_decoding_message_size,
1268 max_encoding_message_size,
1269 );
1270 let res = grpc.unary(method, req).await;
1271 Ok(res)
1272 };
1273 Box::pin(fut)
1274 }
1275 "/side.lending.Query/CurrentInterest" => {
1276 #[allow(non_camel_case_types)]
1277 struct CurrentInterestSvc<T: Query>(pub Arc<T>);
1278 impl<T: Query> tonic::server::UnaryService<super::QueryCurrentInterestRequest>
1279 for CurrentInterestSvc<T>
1280 {
1281 type Response = super::QueryCurrentInterestResponse;
1282 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1283 fn call(
1284 &mut self,
1285 request: tonic::Request<super::QueryCurrentInterestRequest>,
1286 ) -> Self::Future {
1287 let inner = Arc::clone(&self.0);
1288 let fut = async move { (*inner).current_interest(request).await };
1289 Box::pin(fut)
1290 }
1291 }
1292 let accept_compression_encodings = self.accept_compression_encodings;
1293 let send_compression_encodings = self.send_compression_encodings;
1294 let max_decoding_message_size = self.max_decoding_message_size;
1295 let max_encoding_message_size = self.max_encoding_message_size;
1296 let inner = self.inner.clone();
1297 let fut = async move {
1298 let inner = inner.0;
1299 let method = CurrentInterestSvc(inner);
1300 let codec = tonic::codec::ProstCodec::default();
1301 let mut grpc = tonic::server::Grpc::new(codec)
1302 .apply_compression_config(
1303 accept_compression_encodings,
1304 send_compression_encodings,
1305 )
1306 .apply_max_message_size_config(
1307 max_decoding_message_size,
1308 max_encoding_message_size,
1309 );
1310 let res = grpc.unary(method, req).await;
1311 Ok(res)
1312 };
1313 Box::pin(fut)
1314 }
1315 "/side.lending.Query/Referrers" => {
1316 #[allow(non_camel_case_types)]
1317 struct ReferrersSvc<T: Query>(pub Arc<T>);
1318 impl<T: Query> tonic::server::UnaryService<super::QueryReferrersRequest> for ReferrersSvc<T> {
1319 type Response = super::QueryReferrersResponse;
1320 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1321 fn call(
1322 &mut self,
1323 request: tonic::Request<super::QueryReferrersRequest>,
1324 ) -> Self::Future {
1325 let inner = Arc::clone(&self.0);
1326 let fut = async move { (*inner).referrers(request).await };
1327 Box::pin(fut)
1328 }
1329 }
1330 let accept_compression_encodings = self.accept_compression_encodings;
1331 let send_compression_encodings = self.send_compression_encodings;
1332 let max_decoding_message_size = self.max_decoding_message_size;
1333 let max_encoding_message_size = self.max_encoding_message_size;
1334 let inner = self.inner.clone();
1335 let fut = async move {
1336 let inner = inner.0;
1337 let method = ReferrersSvc(inner);
1338 let codec = tonic::codec::ProstCodec::default();
1339 let mut grpc = tonic::server::Grpc::new(codec)
1340 .apply_compression_config(
1341 accept_compression_encodings,
1342 send_compression_encodings,
1343 )
1344 .apply_max_message_size_config(
1345 max_decoding_message_size,
1346 max_encoding_message_size,
1347 );
1348 let res = grpc.unary(method, req).await;
1349 Ok(res)
1350 };
1351 Box::pin(fut)
1352 }
1353 _ => Box::pin(async move {
1354 Ok(http::Response::builder()
1355 .status(200)
1356 .header("grpc-status", "12")
1357 .header("content-type", "application/grpc")
1358 .body(empty_body())
1359 .unwrap())
1360 }),
1361 }
1362 }
1363 }
1364 impl<T: Query> Clone for QueryServer<T> {
1365 fn clone(&self) -> Self {
1366 let inner = self.inner.clone();
1367 Self {
1368 inner,
1369 accept_compression_encodings: self.accept_compression_encodings,
1370 send_compression_encodings: self.send_compression_encodings,
1371 max_decoding_message_size: self.max_decoding_message_size,
1372 max_encoding_message_size: self.max_encoding_message_size,
1373 }
1374 }
1375 }
1376 impl<T: Query> Clone for _Inner<T> {
1377 fn clone(&self) -> Self {
1378 Self(Arc::clone(&self.0))
1379 }
1380 }
1381 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
1382 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1383 write!(f, "{:?}", self.0)
1384 }
1385 }
1386 impl<T: Query> tonic::server::NamedService for QueryServer<T> {
1387 const NAME: &'static str = "side.lending.Query";
1388 }
1389}
1390#[cfg(feature = "grpc")]
1392pub mod msg_client {
1393 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1394 use tonic::codegen::http::Uri;
1395 use tonic::codegen::*;
1396 #[derive(Debug, Clone)]
1397 pub struct MsgClient<T> {
1398 inner: tonic::client::Grpc<T>,
1399 }
1400 #[cfg(feature = "grpc-transport")]
1401 impl MsgClient<tonic::transport::Channel> {
1402 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1404 where
1405 D: TryInto<tonic::transport::Endpoint>,
1406 D::Error: Into<StdError>,
1407 {
1408 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1409 Ok(Self::new(conn))
1410 }
1411 }
1412 impl<T> MsgClient<T>
1413 where
1414 T: tonic::client::GrpcService<tonic::body::BoxBody>,
1415 T::Error: Into<StdError>,
1416 T::ResponseBody: Body<Data = Bytes> + Send + 'static,
1417 <T::ResponseBody as Body>::Error: Into<StdError> + Send,
1418 {
1419 pub fn new(inner: T) -> Self {
1420 let inner = tonic::client::Grpc::new(inner);
1421 Self { inner }
1422 }
1423 pub fn with_origin(inner: T, origin: Uri) -> Self {
1424 let inner = tonic::client::Grpc::with_origin(inner, origin);
1425 Self { inner }
1426 }
1427 pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
1428 where
1429 F: tonic::service::Interceptor,
1430 T::ResponseBody: Default,
1431 T: tonic::codegen::Service<
1432 http::Request<tonic::body::BoxBody>,
1433 Response = http::Response<
1434 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1435 >,
1436 >,
1437 <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
1438 Into<StdError> + Send + Sync,
1439 {
1440 MsgClient::new(InterceptedService::new(inner, interceptor))
1441 }
1442 #[must_use]
1447 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1448 self.inner = self.inner.send_compressed(encoding);
1449 self
1450 }
1451 #[must_use]
1453 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1454 self.inner = self.inner.accept_compressed(encoding);
1455 self
1456 }
1457 #[must_use]
1461 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1462 self.inner = self.inner.max_decoding_message_size(limit);
1463 self
1464 }
1465 #[must_use]
1469 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1470 self.inner = self.inner.max_encoding_message_size(limit);
1471 self
1472 }
1473 pub async fn create_pool(
1474 &mut self,
1475 request: impl tonic::IntoRequest<super::MsgCreatePool>,
1476 ) -> core::result::Result<tonic::Response<super::MsgCreatePoolResponse>, tonic::Status>
1477 {
1478 self.inner.ready().await.map_err(|e| {
1479 tonic::Status::new(
1480 tonic::Code::Unknown,
1481 alloc::format!("Service was not ready: {}", e.into()),
1482 )
1483 })?;
1484 let codec = tonic::codec::ProstCodec::default();
1485 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/CreatePool");
1486 let mut req = request.into_request();
1487 req.extensions_mut()
1488 .insert(GrpcMethod::new("side.lending.Msg", "CreatePool"));
1489 self.inner.unary(req, path, codec).await
1490 }
1491 pub async fn add_liquidity(
1492 &mut self,
1493 request: impl tonic::IntoRequest<super::MsgAddLiquidity>,
1494 ) -> core::result::Result<tonic::Response<super::MsgAddLiquidityResponse>, tonic::Status>
1495 {
1496 self.inner.ready().await.map_err(|e| {
1497 tonic::Status::new(
1498 tonic::Code::Unknown,
1499 alloc::format!("Service was not ready: {}", e.into()),
1500 )
1501 })?;
1502 let codec = tonic::codec::ProstCodec::default();
1503 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/AddLiquidity");
1504 let mut req = request.into_request();
1505 req.extensions_mut()
1506 .insert(GrpcMethod::new("side.lending.Msg", "AddLiquidity"));
1507 self.inner.unary(req, path, codec).await
1508 }
1509 pub async fn remove_liquidity(
1510 &mut self,
1511 request: impl tonic::IntoRequest<super::MsgRemoveLiquidity>,
1512 ) -> core::result::Result<tonic::Response<super::MsgRemoveLiquidityResponse>, tonic::Status>
1513 {
1514 self.inner.ready().await.map_err(|e| {
1515 tonic::Status::new(
1516 tonic::Code::Unknown,
1517 alloc::format!("Service was not ready: {}", e.into()),
1518 )
1519 })?;
1520 let codec = tonic::codec::ProstCodec::default();
1521 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/RemoveLiquidity");
1522 let mut req = request.into_request();
1523 req.extensions_mut()
1524 .insert(GrpcMethod::new("side.lending.Msg", "RemoveLiquidity"));
1525 self.inner.unary(req, path, codec).await
1526 }
1527 pub async fn update_pool_config(
1528 &mut self,
1529 request: impl tonic::IntoRequest<super::MsgUpdatePoolConfig>,
1530 ) -> core::result::Result<tonic::Response<super::MsgUpdatePoolConfigResponse>, tonic::Status>
1531 {
1532 self.inner.ready().await.map_err(|e| {
1533 tonic::Status::new(
1534 tonic::Code::Unknown,
1535 alloc::format!("Service was not ready: {}", e.into()),
1536 )
1537 })?;
1538 let codec = tonic::codec::ProstCodec::default();
1539 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/UpdatePoolConfig");
1540 let mut req = request.into_request();
1541 req.extensions_mut()
1542 .insert(GrpcMethod::new("side.lending.Msg", "UpdatePoolConfig"));
1543 self.inner.unary(req, path, codec).await
1544 }
1545 pub async fn apply(
1546 &mut self,
1547 request: impl tonic::IntoRequest<super::MsgApply>,
1548 ) -> core::result::Result<tonic::Response<super::MsgApplyResponse>, tonic::Status> {
1549 self.inner.ready().await.map_err(|e| {
1550 tonic::Status::new(
1551 tonic::Code::Unknown,
1552 alloc::format!("Service was not ready: {}", e.into()),
1553 )
1554 })?;
1555 let codec = tonic::codec::ProstCodec::default();
1556 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Apply");
1557 let mut req = request.into_request();
1558 req.extensions_mut()
1559 .insert(GrpcMethod::new("side.lending.Msg", "Apply"));
1560 self.inner.unary(req, path, codec).await
1561 }
1562 pub async fn submit_cets(
1563 &mut self,
1564 request: impl tonic::IntoRequest<super::MsgSubmitCets>,
1565 ) -> core::result::Result<tonic::Response<super::MsgSubmitCetsResponse>, tonic::Status>
1566 {
1567 self.inner.ready().await.map_err(|e| {
1568 tonic::Status::new(
1569 tonic::Code::Unknown,
1570 alloc::format!("Service was not ready: {}", e.into()),
1571 )
1572 })?;
1573 let codec = tonic::codec::ProstCodec::default();
1574 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/SubmitCets");
1575 let mut req = request.into_request();
1576 req.extensions_mut()
1577 .insert(GrpcMethod::new("side.lending.Msg", "SubmitCets"));
1578 self.inner.unary(req, path, codec).await
1579 }
1580 pub async fn submit_deposit_transaction(
1581 &mut self,
1582 request: impl tonic::IntoRequest<super::MsgSubmitDepositTransaction>,
1583 ) -> core::result::Result<
1584 tonic::Response<super::MsgSubmitDepositTransactionResponse>,
1585 tonic::Status,
1586 > {
1587 self.inner.ready().await.map_err(|e| {
1588 tonic::Status::new(
1589 tonic::Code::Unknown,
1590 alloc::format!("Service was not ready: {}", e.into()),
1591 )
1592 })?;
1593 let codec = tonic::codec::ProstCodec::default();
1594 let path =
1595 http::uri::PathAndQuery::from_static("/side.lending.Msg/SubmitDepositTransaction");
1596 let mut req = request.into_request();
1597 req.extensions_mut().insert(GrpcMethod::new(
1598 "side.lending.Msg",
1599 "SubmitDepositTransaction",
1600 ));
1601 self.inner.unary(req, path, codec).await
1602 }
1603 pub async fn redeem(
1604 &mut self,
1605 request: impl tonic::IntoRequest<super::MsgRedeem>,
1606 ) -> core::result::Result<tonic::Response<super::MsgRedeemResponse>, tonic::Status>
1607 {
1608 self.inner.ready().await.map_err(|e| {
1609 tonic::Status::new(
1610 tonic::Code::Unknown,
1611 alloc::format!("Service was not ready: {}", e.into()),
1612 )
1613 })?;
1614 let codec = tonic::codec::ProstCodec::default();
1615 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Redeem");
1616 let mut req = request.into_request();
1617 req.extensions_mut()
1618 .insert(GrpcMethod::new("side.lending.Msg", "Redeem"));
1619 self.inner.unary(req, path, codec).await
1620 }
1621 pub async fn repay(
1622 &mut self,
1623 request: impl tonic::IntoRequest<super::MsgRepay>,
1624 ) -> core::result::Result<tonic::Response<super::MsgRepayResponse>, tonic::Status> {
1625 self.inner.ready().await.map_err(|e| {
1626 tonic::Status::new(
1627 tonic::Code::Unknown,
1628 alloc::format!("Service was not ready: {}", e.into()),
1629 )
1630 })?;
1631 let codec = tonic::codec::ProstCodec::default();
1632 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Repay");
1633 let mut req = request.into_request();
1634 req.extensions_mut()
1635 .insert(GrpcMethod::new("side.lending.Msg", "Repay"));
1636 self.inner.unary(req, path, codec).await
1637 }
1638 pub async fn register_referrer(
1639 &mut self,
1640 request: impl tonic::IntoRequest<super::MsgRegisterReferrer>,
1641 ) -> core::result::Result<tonic::Response<super::MsgRegisterReferrerResponse>, tonic::Status>
1642 {
1643 self.inner.ready().await.map_err(|e| {
1644 tonic::Status::new(
1645 tonic::Code::Unknown,
1646 alloc::format!("Service was not ready: {}", e.into()),
1647 )
1648 })?;
1649 let codec = tonic::codec::ProstCodec::default();
1650 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/RegisterReferrer");
1651 let mut req = request.into_request();
1652 req.extensions_mut()
1653 .insert(GrpcMethod::new("side.lending.Msg", "RegisterReferrer"));
1654 self.inner.unary(req, path, codec).await
1655 }
1656 pub async fn update_referrer(
1657 &mut self,
1658 request: impl tonic::IntoRequest<super::MsgUpdateReferrer>,
1659 ) -> core::result::Result<tonic::Response<super::MsgUpdateReferrerResponse>, tonic::Status>
1660 {
1661 self.inner.ready().await.map_err(|e| {
1662 tonic::Status::new(
1663 tonic::Code::Unknown,
1664 alloc::format!("Service was not ready: {}", e.into()),
1665 )
1666 })?;
1667 let codec = tonic::codec::ProstCodec::default();
1668 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/UpdateReferrer");
1669 let mut req = request.into_request();
1670 req.extensions_mut()
1671 .insert(GrpcMethod::new("side.lending.Msg", "UpdateReferrer"));
1672 self.inner.unary(req, path, codec).await
1673 }
1674 pub async fn update_params(
1675 &mut self,
1676 request: impl tonic::IntoRequest<super::MsgUpdateParams>,
1677 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>
1678 {
1679 self.inner.ready().await.map_err(|e| {
1680 tonic::Status::new(
1681 tonic::Code::Unknown,
1682 alloc::format!("Service was not ready: {}", e.into()),
1683 )
1684 })?;
1685 let codec = tonic::codec::ProstCodec::default();
1686 let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/UpdateParams");
1687 let mut req = request.into_request();
1688 req.extensions_mut()
1689 .insert(GrpcMethod::new("side.lending.Msg", "UpdateParams"));
1690 self.inner.unary(req, path, codec).await
1691 }
1692 }
1693}
1694#[cfg(feature = "grpc")]
1696pub mod msg_server {
1697 #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1698 use tonic::codegen::*;
1699 #[async_trait]
1701 pub trait Msg: Send + Sync + 'static {
1702 async fn create_pool(
1703 &self,
1704 request: tonic::Request<super::MsgCreatePool>,
1705 ) -> core::result::Result<tonic::Response<super::MsgCreatePoolResponse>, tonic::Status>;
1706 async fn add_liquidity(
1707 &self,
1708 request: tonic::Request<super::MsgAddLiquidity>,
1709 ) -> core::result::Result<tonic::Response<super::MsgAddLiquidityResponse>, tonic::Status>;
1710 async fn remove_liquidity(
1711 &self,
1712 request: tonic::Request<super::MsgRemoveLiquidity>,
1713 ) -> core::result::Result<tonic::Response<super::MsgRemoveLiquidityResponse>, tonic::Status>;
1714 async fn update_pool_config(
1715 &self,
1716 request: tonic::Request<super::MsgUpdatePoolConfig>,
1717 ) -> core::result::Result<tonic::Response<super::MsgUpdatePoolConfigResponse>, tonic::Status>;
1718 async fn apply(
1719 &self,
1720 request: tonic::Request<super::MsgApply>,
1721 ) -> core::result::Result<tonic::Response<super::MsgApplyResponse>, tonic::Status>;
1722 async fn submit_cets(
1723 &self,
1724 request: tonic::Request<super::MsgSubmitCets>,
1725 ) -> core::result::Result<tonic::Response<super::MsgSubmitCetsResponse>, tonic::Status>;
1726 async fn submit_deposit_transaction(
1727 &self,
1728 request: tonic::Request<super::MsgSubmitDepositTransaction>,
1729 ) -> core::result::Result<
1730 tonic::Response<super::MsgSubmitDepositTransactionResponse>,
1731 tonic::Status,
1732 >;
1733 async fn redeem(
1734 &self,
1735 request: tonic::Request<super::MsgRedeem>,
1736 ) -> core::result::Result<tonic::Response<super::MsgRedeemResponse>, tonic::Status>;
1737 async fn repay(
1738 &self,
1739 request: tonic::Request<super::MsgRepay>,
1740 ) -> core::result::Result<tonic::Response<super::MsgRepayResponse>, tonic::Status>;
1741 async fn register_referrer(
1742 &self,
1743 request: tonic::Request<super::MsgRegisterReferrer>,
1744 ) -> core::result::Result<tonic::Response<super::MsgRegisterReferrerResponse>, tonic::Status>;
1745 async fn update_referrer(
1746 &self,
1747 request: tonic::Request<super::MsgUpdateReferrer>,
1748 ) -> core::result::Result<tonic::Response<super::MsgUpdateReferrerResponse>, tonic::Status>;
1749 async fn update_params(
1750 &self,
1751 request: tonic::Request<super::MsgUpdateParams>,
1752 ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>;
1753 }
1754 #[derive(Debug)]
1755 pub struct MsgServer<T: Msg> {
1756 inner: _Inner<T>,
1757 accept_compression_encodings: EnabledCompressionEncodings,
1758 send_compression_encodings: EnabledCompressionEncodings,
1759 max_decoding_message_size: Option<usize>,
1760 max_encoding_message_size: Option<usize>,
1761 }
1762 struct _Inner<T>(Arc<T>);
1763 impl<T: Msg> MsgServer<T> {
1764 pub fn new(inner: T) -> Self {
1765 Self::from_arc(Arc::new(inner))
1766 }
1767 pub fn from_arc(inner: Arc<T>) -> Self {
1768 let inner = _Inner(inner);
1769 Self {
1770 inner,
1771 accept_compression_encodings: Default::default(),
1772 send_compression_encodings: Default::default(),
1773 max_decoding_message_size: None,
1774 max_encoding_message_size: None,
1775 }
1776 }
1777 pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1778 where
1779 F: tonic::service::Interceptor,
1780 {
1781 InterceptedService::new(Self::new(inner), interceptor)
1782 }
1783 #[must_use]
1785 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1786 self.accept_compression_encodings.enable(encoding);
1787 self
1788 }
1789 #[must_use]
1791 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1792 self.send_compression_encodings.enable(encoding);
1793 self
1794 }
1795 #[must_use]
1799 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1800 self.max_decoding_message_size = Some(limit);
1801 self
1802 }
1803 #[must_use]
1807 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1808 self.max_encoding_message_size = Some(limit);
1809 self
1810 }
1811 }
1812 impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
1813 where
1814 T: Msg,
1815 B: Body + Send + 'static,
1816 B::Error: Into<StdError> + Send + 'static,
1817 {
1818 type Response = http::Response<tonic::body::BoxBody>;
1819 type Error = std::convert::Infallible;
1820 type Future = BoxFuture<Self::Response, Self::Error>;
1821 fn poll_ready(
1822 &mut self,
1823 _cx: &mut Context<'_>,
1824 ) -> Poll<core::result::Result<(), Self::Error>> {
1825 Poll::Ready(Ok(()))
1826 }
1827 fn call(&mut self, req: http::Request<B>) -> Self::Future {
1828 let inner = self.inner.clone();
1829 match req.uri().path() {
1830 "/side.lending.Msg/CreatePool" => {
1831 #[allow(non_camel_case_types)]
1832 struct CreatePoolSvc<T: Msg>(pub Arc<T>);
1833 impl<T: Msg> tonic::server::UnaryService<super::MsgCreatePool> for CreatePoolSvc<T> {
1834 type Response = super::MsgCreatePoolResponse;
1835 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1836 fn call(
1837 &mut self,
1838 request: tonic::Request<super::MsgCreatePool>,
1839 ) -> Self::Future {
1840 let inner = Arc::clone(&self.0);
1841 let fut = async move { (*inner).create_pool(request).await };
1842 Box::pin(fut)
1843 }
1844 }
1845 let accept_compression_encodings = self.accept_compression_encodings;
1846 let send_compression_encodings = self.send_compression_encodings;
1847 let max_decoding_message_size = self.max_decoding_message_size;
1848 let max_encoding_message_size = self.max_encoding_message_size;
1849 let inner = self.inner.clone();
1850 let fut = async move {
1851 let inner = inner.0;
1852 let method = CreatePoolSvc(inner);
1853 let codec = tonic::codec::ProstCodec::default();
1854 let mut grpc = tonic::server::Grpc::new(codec)
1855 .apply_compression_config(
1856 accept_compression_encodings,
1857 send_compression_encodings,
1858 )
1859 .apply_max_message_size_config(
1860 max_decoding_message_size,
1861 max_encoding_message_size,
1862 );
1863 let res = grpc.unary(method, req).await;
1864 Ok(res)
1865 };
1866 Box::pin(fut)
1867 }
1868 "/side.lending.Msg/AddLiquidity" => {
1869 #[allow(non_camel_case_types)]
1870 struct AddLiquiditySvc<T: Msg>(pub Arc<T>);
1871 impl<T: Msg> tonic::server::UnaryService<super::MsgAddLiquidity> for AddLiquiditySvc<T> {
1872 type Response = super::MsgAddLiquidityResponse;
1873 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1874 fn call(
1875 &mut self,
1876 request: tonic::Request<super::MsgAddLiquidity>,
1877 ) -> Self::Future {
1878 let inner = Arc::clone(&self.0);
1879 let fut = async move { (*inner).add_liquidity(request).await };
1880 Box::pin(fut)
1881 }
1882 }
1883 let accept_compression_encodings = self.accept_compression_encodings;
1884 let send_compression_encodings = self.send_compression_encodings;
1885 let max_decoding_message_size = self.max_decoding_message_size;
1886 let max_encoding_message_size = self.max_encoding_message_size;
1887 let inner = self.inner.clone();
1888 let fut = async move {
1889 let inner = inner.0;
1890 let method = AddLiquiditySvc(inner);
1891 let codec = tonic::codec::ProstCodec::default();
1892 let mut grpc = tonic::server::Grpc::new(codec)
1893 .apply_compression_config(
1894 accept_compression_encodings,
1895 send_compression_encodings,
1896 )
1897 .apply_max_message_size_config(
1898 max_decoding_message_size,
1899 max_encoding_message_size,
1900 );
1901 let res = grpc.unary(method, req).await;
1902 Ok(res)
1903 };
1904 Box::pin(fut)
1905 }
1906 "/side.lending.Msg/RemoveLiquidity" => {
1907 #[allow(non_camel_case_types)]
1908 struct RemoveLiquiditySvc<T: Msg>(pub Arc<T>);
1909 impl<T: Msg> tonic::server::UnaryService<super::MsgRemoveLiquidity> for RemoveLiquiditySvc<T> {
1910 type Response = super::MsgRemoveLiquidityResponse;
1911 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1912 fn call(
1913 &mut self,
1914 request: tonic::Request<super::MsgRemoveLiquidity>,
1915 ) -> Self::Future {
1916 let inner = Arc::clone(&self.0);
1917 let fut = async move { (*inner).remove_liquidity(request).await };
1918 Box::pin(fut)
1919 }
1920 }
1921 let accept_compression_encodings = self.accept_compression_encodings;
1922 let send_compression_encodings = self.send_compression_encodings;
1923 let max_decoding_message_size = self.max_decoding_message_size;
1924 let max_encoding_message_size = self.max_encoding_message_size;
1925 let inner = self.inner.clone();
1926 let fut = async move {
1927 let inner = inner.0;
1928 let method = RemoveLiquiditySvc(inner);
1929 let codec = tonic::codec::ProstCodec::default();
1930 let mut grpc = tonic::server::Grpc::new(codec)
1931 .apply_compression_config(
1932 accept_compression_encodings,
1933 send_compression_encodings,
1934 )
1935 .apply_max_message_size_config(
1936 max_decoding_message_size,
1937 max_encoding_message_size,
1938 );
1939 let res = grpc.unary(method, req).await;
1940 Ok(res)
1941 };
1942 Box::pin(fut)
1943 }
1944 "/side.lending.Msg/UpdatePoolConfig" => {
1945 #[allow(non_camel_case_types)]
1946 struct UpdatePoolConfigSvc<T: Msg>(pub Arc<T>);
1947 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdatePoolConfig> for UpdatePoolConfigSvc<T> {
1948 type Response = super::MsgUpdatePoolConfigResponse;
1949 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1950 fn call(
1951 &mut self,
1952 request: tonic::Request<super::MsgUpdatePoolConfig>,
1953 ) -> Self::Future {
1954 let inner = Arc::clone(&self.0);
1955 let fut = async move { (*inner).update_pool_config(request).await };
1956 Box::pin(fut)
1957 }
1958 }
1959 let accept_compression_encodings = self.accept_compression_encodings;
1960 let send_compression_encodings = self.send_compression_encodings;
1961 let max_decoding_message_size = self.max_decoding_message_size;
1962 let max_encoding_message_size = self.max_encoding_message_size;
1963 let inner = self.inner.clone();
1964 let fut = async move {
1965 let inner = inner.0;
1966 let method = UpdatePoolConfigSvc(inner);
1967 let codec = tonic::codec::ProstCodec::default();
1968 let mut grpc = tonic::server::Grpc::new(codec)
1969 .apply_compression_config(
1970 accept_compression_encodings,
1971 send_compression_encodings,
1972 )
1973 .apply_max_message_size_config(
1974 max_decoding_message_size,
1975 max_encoding_message_size,
1976 );
1977 let res = grpc.unary(method, req).await;
1978 Ok(res)
1979 };
1980 Box::pin(fut)
1981 }
1982 "/side.lending.Msg/Apply" => {
1983 #[allow(non_camel_case_types)]
1984 struct ApplySvc<T: Msg>(pub Arc<T>);
1985 impl<T: Msg> tonic::server::UnaryService<super::MsgApply> for ApplySvc<T> {
1986 type Response = super::MsgApplyResponse;
1987 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1988 fn call(
1989 &mut self,
1990 request: tonic::Request<super::MsgApply>,
1991 ) -> Self::Future {
1992 let inner = Arc::clone(&self.0);
1993 let fut = async move { (*inner).apply(request).await };
1994 Box::pin(fut)
1995 }
1996 }
1997 let accept_compression_encodings = self.accept_compression_encodings;
1998 let send_compression_encodings = self.send_compression_encodings;
1999 let max_decoding_message_size = self.max_decoding_message_size;
2000 let max_encoding_message_size = self.max_encoding_message_size;
2001 let inner = self.inner.clone();
2002 let fut = async move {
2003 let inner = inner.0;
2004 let method = ApplySvc(inner);
2005 let codec = tonic::codec::ProstCodec::default();
2006 let mut grpc = tonic::server::Grpc::new(codec)
2007 .apply_compression_config(
2008 accept_compression_encodings,
2009 send_compression_encodings,
2010 )
2011 .apply_max_message_size_config(
2012 max_decoding_message_size,
2013 max_encoding_message_size,
2014 );
2015 let res = grpc.unary(method, req).await;
2016 Ok(res)
2017 };
2018 Box::pin(fut)
2019 }
2020 "/side.lending.Msg/SubmitCets" => {
2021 #[allow(non_camel_case_types)]
2022 struct SubmitCetsSvc<T: Msg>(pub Arc<T>);
2023 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitCets> for SubmitCetsSvc<T> {
2024 type Response = super::MsgSubmitCetsResponse;
2025 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2026 fn call(
2027 &mut self,
2028 request: tonic::Request<super::MsgSubmitCets>,
2029 ) -> Self::Future {
2030 let inner = Arc::clone(&self.0);
2031 let fut = async move { (*inner).submit_cets(request).await };
2032 Box::pin(fut)
2033 }
2034 }
2035 let accept_compression_encodings = self.accept_compression_encodings;
2036 let send_compression_encodings = self.send_compression_encodings;
2037 let max_decoding_message_size = self.max_decoding_message_size;
2038 let max_encoding_message_size = self.max_encoding_message_size;
2039 let inner = self.inner.clone();
2040 let fut = async move {
2041 let inner = inner.0;
2042 let method = SubmitCetsSvc(inner);
2043 let codec = tonic::codec::ProstCodec::default();
2044 let mut grpc = tonic::server::Grpc::new(codec)
2045 .apply_compression_config(
2046 accept_compression_encodings,
2047 send_compression_encodings,
2048 )
2049 .apply_max_message_size_config(
2050 max_decoding_message_size,
2051 max_encoding_message_size,
2052 );
2053 let res = grpc.unary(method, req).await;
2054 Ok(res)
2055 };
2056 Box::pin(fut)
2057 }
2058 "/side.lending.Msg/SubmitDepositTransaction" => {
2059 #[allow(non_camel_case_types)]
2060 struct SubmitDepositTransactionSvc<T: Msg>(pub Arc<T>);
2061 impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitDepositTransaction>
2062 for SubmitDepositTransactionSvc<T>
2063 {
2064 type Response = super::MsgSubmitDepositTransactionResponse;
2065 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2066 fn call(
2067 &mut self,
2068 request: tonic::Request<super::MsgSubmitDepositTransaction>,
2069 ) -> Self::Future {
2070 let inner = Arc::clone(&self.0);
2071 let fut =
2072 async move { (*inner).submit_deposit_transaction(request).await };
2073 Box::pin(fut)
2074 }
2075 }
2076 let accept_compression_encodings = self.accept_compression_encodings;
2077 let send_compression_encodings = self.send_compression_encodings;
2078 let max_decoding_message_size = self.max_decoding_message_size;
2079 let max_encoding_message_size = self.max_encoding_message_size;
2080 let inner = self.inner.clone();
2081 let fut = async move {
2082 let inner = inner.0;
2083 let method = SubmitDepositTransactionSvc(inner);
2084 let codec = tonic::codec::ProstCodec::default();
2085 let mut grpc = tonic::server::Grpc::new(codec)
2086 .apply_compression_config(
2087 accept_compression_encodings,
2088 send_compression_encodings,
2089 )
2090 .apply_max_message_size_config(
2091 max_decoding_message_size,
2092 max_encoding_message_size,
2093 );
2094 let res = grpc.unary(method, req).await;
2095 Ok(res)
2096 };
2097 Box::pin(fut)
2098 }
2099 "/side.lending.Msg/Redeem" => {
2100 #[allow(non_camel_case_types)]
2101 struct RedeemSvc<T: Msg>(pub Arc<T>);
2102 impl<T: Msg> tonic::server::UnaryService<super::MsgRedeem> for RedeemSvc<T> {
2103 type Response = super::MsgRedeemResponse;
2104 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2105 fn call(
2106 &mut self,
2107 request: tonic::Request<super::MsgRedeem>,
2108 ) -> Self::Future {
2109 let inner = Arc::clone(&self.0);
2110 let fut = async move { (*inner).redeem(request).await };
2111 Box::pin(fut)
2112 }
2113 }
2114 let accept_compression_encodings = self.accept_compression_encodings;
2115 let send_compression_encodings = self.send_compression_encodings;
2116 let max_decoding_message_size = self.max_decoding_message_size;
2117 let max_encoding_message_size = self.max_encoding_message_size;
2118 let inner = self.inner.clone();
2119 let fut = async move {
2120 let inner = inner.0;
2121 let method = RedeemSvc(inner);
2122 let codec = tonic::codec::ProstCodec::default();
2123 let mut grpc = tonic::server::Grpc::new(codec)
2124 .apply_compression_config(
2125 accept_compression_encodings,
2126 send_compression_encodings,
2127 )
2128 .apply_max_message_size_config(
2129 max_decoding_message_size,
2130 max_encoding_message_size,
2131 );
2132 let res = grpc.unary(method, req).await;
2133 Ok(res)
2134 };
2135 Box::pin(fut)
2136 }
2137 "/side.lending.Msg/Repay" => {
2138 #[allow(non_camel_case_types)]
2139 struct RepaySvc<T: Msg>(pub Arc<T>);
2140 impl<T: Msg> tonic::server::UnaryService<super::MsgRepay> for RepaySvc<T> {
2141 type Response = super::MsgRepayResponse;
2142 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2143 fn call(
2144 &mut self,
2145 request: tonic::Request<super::MsgRepay>,
2146 ) -> Self::Future {
2147 let inner = Arc::clone(&self.0);
2148 let fut = async move { (*inner).repay(request).await };
2149 Box::pin(fut)
2150 }
2151 }
2152 let accept_compression_encodings = self.accept_compression_encodings;
2153 let send_compression_encodings = self.send_compression_encodings;
2154 let max_decoding_message_size = self.max_decoding_message_size;
2155 let max_encoding_message_size = self.max_encoding_message_size;
2156 let inner = self.inner.clone();
2157 let fut = async move {
2158 let inner = inner.0;
2159 let method = RepaySvc(inner);
2160 let codec = tonic::codec::ProstCodec::default();
2161 let mut grpc = tonic::server::Grpc::new(codec)
2162 .apply_compression_config(
2163 accept_compression_encodings,
2164 send_compression_encodings,
2165 )
2166 .apply_max_message_size_config(
2167 max_decoding_message_size,
2168 max_encoding_message_size,
2169 );
2170 let res = grpc.unary(method, req).await;
2171 Ok(res)
2172 };
2173 Box::pin(fut)
2174 }
2175 "/side.lending.Msg/RegisterReferrer" => {
2176 #[allow(non_camel_case_types)]
2177 struct RegisterReferrerSvc<T: Msg>(pub Arc<T>);
2178 impl<T: Msg> tonic::server::UnaryService<super::MsgRegisterReferrer> for RegisterReferrerSvc<T> {
2179 type Response = super::MsgRegisterReferrerResponse;
2180 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2181 fn call(
2182 &mut self,
2183 request: tonic::Request<super::MsgRegisterReferrer>,
2184 ) -> Self::Future {
2185 let inner = Arc::clone(&self.0);
2186 let fut = async move { (*inner).register_referrer(request).await };
2187 Box::pin(fut)
2188 }
2189 }
2190 let accept_compression_encodings = self.accept_compression_encodings;
2191 let send_compression_encodings = self.send_compression_encodings;
2192 let max_decoding_message_size = self.max_decoding_message_size;
2193 let max_encoding_message_size = self.max_encoding_message_size;
2194 let inner = self.inner.clone();
2195 let fut = async move {
2196 let inner = inner.0;
2197 let method = RegisterReferrerSvc(inner);
2198 let codec = tonic::codec::ProstCodec::default();
2199 let mut grpc = tonic::server::Grpc::new(codec)
2200 .apply_compression_config(
2201 accept_compression_encodings,
2202 send_compression_encodings,
2203 )
2204 .apply_max_message_size_config(
2205 max_decoding_message_size,
2206 max_encoding_message_size,
2207 );
2208 let res = grpc.unary(method, req).await;
2209 Ok(res)
2210 };
2211 Box::pin(fut)
2212 }
2213 "/side.lending.Msg/UpdateReferrer" => {
2214 #[allow(non_camel_case_types)]
2215 struct UpdateReferrerSvc<T: Msg>(pub Arc<T>);
2216 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateReferrer> for UpdateReferrerSvc<T> {
2217 type Response = super::MsgUpdateReferrerResponse;
2218 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2219 fn call(
2220 &mut self,
2221 request: tonic::Request<super::MsgUpdateReferrer>,
2222 ) -> Self::Future {
2223 let inner = Arc::clone(&self.0);
2224 let fut = async move { (*inner).update_referrer(request).await };
2225 Box::pin(fut)
2226 }
2227 }
2228 let accept_compression_encodings = self.accept_compression_encodings;
2229 let send_compression_encodings = self.send_compression_encodings;
2230 let max_decoding_message_size = self.max_decoding_message_size;
2231 let max_encoding_message_size = self.max_encoding_message_size;
2232 let inner = self.inner.clone();
2233 let fut = async move {
2234 let inner = inner.0;
2235 let method = UpdateReferrerSvc(inner);
2236 let codec = tonic::codec::ProstCodec::default();
2237 let mut grpc = tonic::server::Grpc::new(codec)
2238 .apply_compression_config(
2239 accept_compression_encodings,
2240 send_compression_encodings,
2241 )
2242 .apply_max_message_size_config(
2243 max_decoding_message_size,
2244 max_encoding_message_size,
2245 );
2246 let res = grpc.unary(method, req).await;
2247 Ok(res)
2248 };
2249 Box::pin(fut)
2250 }
2251 "/side.lending.Msg/UpdateParams" => {
2252 #[allow(non_camel_case_types)]
2253 struct UpdateParamsSvc<T: Msg>(pub Arc<T>);
2254 impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateParams> for UpdateParamsSvc<T> {
2255 type Response = super::MsgUpdateParamsResponse;
2256 type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
2257 fn call(
2258 &mut self,
2259 request: tonic::Request<super::MsgUpdateParams>,
2260 ) -> Self::Future {
2261 let inner = Arc::clone(&self.0);
2262 let fut = async move { (*inner).update_params(request).await };
2263 Box::pin(fut)
2264 }
2265 }
2266 let accept_compression_encodings = self.accept_compression_encodings;
2267 let send_compression_encodings = self.send_compression_encodings;
2268 let max_decoding_message_size = self.max_decoding_message_size;
2269 let max_encoding_message_size = self.max_encoding_message_size;
2270 let inner = self.inner.clone();
2271 let fut = async move {
2272 let inner = inner.0;
2273 let method = UpdateParamsSvc(inner);
2274 let codec = tonic::codec::ProstCodec::default();
2275 let mut grpc = tonic::server::Grpc::new(codec)
2276 .apply_compression_config(
2277 accept_compression_encodings,
2278 send_compression_encodings,
2279 )
2280 .apply_max_message_size_config(
2281 max_decoding_message_size,
2282 max_encoding_message_size,
2283 );
2284 let res = grpc.unary(method, req).await;
2285 Ok(res)
2286 };
2287 Box::pin(fut)
2288 }
2289 _ => Box::pin(async move {
2290 Ok(http::Response::builder()
2291 .status(200)
2292 .header("grpc-status", "12")
2293 .header("content-type", "application/grpc")
2294 .body(empty_body())
2295 .unwrap())
2296 }),
2297 }
2298 }
2299 }
2300 impl<T: Msg> Clone for MsgServer<T> {
2301 fn clone(&self) -> Self {
2302 let inner = self.inner.clone();
2303 Self {
2304 inner,
2305 accept_compression_encodings: self.accept_compression_encodings,
2306 send_compression_encodings: self.send_compression_encodings,
2307 max_decoding_message_size: self.max_decoding_message_size,
2308 max_encoding_message_size: self.max_encoding_message_size,
2309 }
2310 }
2311 }
2312 impl<T: Msg> Clone for _Inner<T> {
2313 fn clone(&self) -> Self {
2314 Self(Arc::clone(&self.0))
2315 }
2316 }
2317 impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
2318 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2319 write!(f, "{:?}", self.0)
2320 }
2321 }
2322 impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
2323 const NAME: &'static str = "side.lending.Msg";
2324 }
2325}