1#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct LqtVotingNotesRequest {
4 #[prost(uint64, tag = "1")]
6 pub epoch_index: u64,
7 #[prost(message, optional, tag = "2")]
9 pub account_filter: ::core::option::Option<
10 super::super::core::keys::v1::AddressIndex,
11 >,
12}
13impl ::prost::Name for LqtVotingNotesRequest {
14 const NAME: &'static str = "LqtVotingNotesRequest";
15 const PACKAGE: &'static str = "penumbra.view.v1";
16 fn full_name() -> ::prost::alloc::string::String {
17 "penumbra.view.v1.LqtVotingNotesRequest".into()
18 }
19 fn type_url() -> ::prost::alloc::string::String {
20 "/penumbra.view.v1.LqtVotingNotesRequest".into()
21 }
22}
23#[derive(Clone, PartialEq, ::prost::Message)]
24pub struct LqtVotingNotesResponse {
25 #[prost(message, optional, tag = "1")]
27 pub note_record: ::core::option::Option<SpendableNoteRecord>,
28 #[prost(bool, tag = "2")]
30 pub already_voted: bool,
31}
32impl ::prost::Name for LqtVotingNotesResponse {
33 const NAME: &'static str = "LqtVotingNotesResponse";
34 const PACKAGE: &'static str = "penumbra.view.v1";
35 fn full_name() -> ::prost::alloc::string::String {
36 "penumbra.view.v1.LqtVotingNotesResponse".into()
37 }
38 fn type_url() -> ::prost::alloc::string::String {
39 "/penumbra.view.v1.LqtVotingNotesResponse".into()
40 }
41}
42#[derive(Clone, PartialEq, ::prost::Message)]
46pub struct TournamentVotesRequest {
47 #[prost(uint64, tag = "1")]
49 pub epoch_index: u64,
50 #[prost(uint64, tag = "2")]
52 pub block_height: u64,
53 #[prost(message, optional, tag = "3")]
55 pub account_filter: ::core::option::Option<
56 super::super::core::keys::v1::AddressIndex,
57 >,
58}
59impl ::prost::Name for TournamentVotesRequest {
60 const NAME: &'static str = "TournamentVotesRequest";
61 const PACKAGE: &'static str = "penumbra.view.v1";
62 fn full_name() -> ::prost::alloc::string::String {
63 "penumbra.view.v1.TournamentVotesRequest".into()
64 }
65 fn type_url() -> ::prost::alloc::string::String {
66 "/penumbra.view.v1.TournamentVotesRequest".into()
67 }
68}
69#[derive(Clone, PartialEq, ::prost::Message)]
70pub struct TournamentVotesResponse {
71 #[prost(message, repeated, tag = "1")]
73 pub votes: ::prost::alloc::vec::Vec<tournament_votes_response::Vote>,
74}
75pub mod tournament_votes_response {
77 #[derive(Clone, PartialEq, ::prost::Message)]
78 pub struct Vote {
79 #[prost(message, optional, tag = "1")]
81 pub incentivized_asset: ::core::option::Option<
82 super::super::super::core::asset::v1::AssetId,
83 >,
84 #[prost(message, optional, tag = "2")]
86 pub vote_power: ::core::option::Option<
87 super::super::super::core::num::v1::Amount,
88 >,
89 #[prost(message, optional, tag = "3")]
91 pub reward: ::core::option::Option<super::super::super::core::asset::v1::Value>,
92 #[prost(message, optional, tag = "4")]
94 pub transaction: ::core::option::Option<
95 super::super::super::core::txhash::v1::TransactionId,
96 >,
97 #[prost(uint64, tag = "5")]
99 pub epoch_index: u64,
100 }
101 impl ::prost::Name for Vote {
102 const NAME: &'static str = "Vote";
103 const PACKAGE: &'static str = "penumbra.view.v1";
104 fn full_name() -> ::prost::alloc::string::String {
105 "penumbra.view.v1.TournamentVotesResponse.Vote".into()
106 }
107 fn type_url() -> ::prost::alloc::string::String {
108 "/penumbra.view.v1.TournamentVotesResponse.Vote".into()
109 }
110 }
111}
112impl ::prost::Name for TournamentVotesResponse {
113 const NAME: &'static str = "TournamentVotesResponse";
114 const PACKAGE: &'static str = "penumbra.view.v1";
115 fn full_name() -> ::prost::alloc::string::String {
116 "penumbra.view.v1.TournamentVotesResponse".into()
117 }
118 fn type_url() -> ::prost::alloc::string::String {
119 "/penumbra.view.v1.TournamentVotesResponse".into()
120 }
121}
122#[derive(Clone, Copy, PartialEq, ::prost::Message)]
125pub struct TransparentAddressRequest {}
126impl ::prost::Name for TransparentAddressRequest {
127 const NAME: &'static str = "TransparentAddressRequest";
128 const PACKAGE: &'static str = "penumbra.view.v1";
129 fn full_name() -> ::prost::alloc::string::String {
130 "penumbra.view.v1.TransparentAddressRequest".into()
131 }
132 fn type_url() -> ::prost::alloc::string::String {
133 "/penumbra.view.v1.TransparentAddressRequest".into()
134 }
135}
136#[derive(Clone, PartialEq, ::prost::Message)]
137pub struct TransparentAddressResponse {
138 #[prost(message, optional, tag = "1")]
140 pub address: ::core::option::Option<super::super::core::keys::v1::Address>,
141 #[prost(string, tag = "2")]
143 pub encoding: ::prost::alloc::string::String,
144}
145impl ::prost::Name for TransparentAddressResponse {
146 const NAME: &'static str = "TransparentAddressResponse";
147 const PACKAGE: &'static str = "penumbra.view.v1";
148 fn full_name() -> ::prost::alloc::string::String {
149 "penumbra.view.v1.TransparentAddressResponse".into()
150 }
151 fn type_url() -> ::prost::alloc::string::String {
152 "/penumbra.view.v1.TransparentAddressResponse".into()
153 }
154}
155#[derive(Clone, PartialEq, ::prost::Message)]
158pub struct AuctionsRequest {
159 #[prost(message, optional, tag = "1")]
161 pub account_filter: ::core::option::Option<
162 super::super::core::keys::v1::AddressIndex,
163 >,
164 #[prost(bool, tag = "2")]
166 pub include_inactive: bool,
167 #[prost(bool, tag = "3")]
169 pub query_latest_state: bool,
170 #[prost(message, repeated, tag = "4")]
172 pub auction_ids_filter: ::prost::alloc::vec::Vec<
173 super::super::core::component::auction::v1::AuctionId,
174 >,
175}
176impl ::prost::Name for AuctionsRequest {
177 const NAME: &'static str = "AuctionsRequest";
178 const PACKAGE: &'static str = "penumbra.view.v1";
179 fn full_name() -> ::prost::alloc::string::String {
180 "penumbra.view.v1.AuctionsRequest".into()
181 }
182 fn type_url() -> ::prost::alloc::string::String {
183 "/penumbra.view.v1.AuctionsRequest".into()
184 }
185}
186#[derive(Clone, PartialEq, ::prost::Message)]
187pub struct AuctionsResponse {
188 #[prost(message, optional, tag = "1")]
189 pub id: ::core::option::Option<
190 super::super::core::component::auction::v1::AuctionId,
191 >,
192 #[prost(message, optional, tag = "2")]
196 pub auction: ::core::option::Option<::pbjson_types::Any>,
197 #[prost(message, repeated, tag = "3")]
202 pub positions: ::prost::alloc::vec::Vec<
203 super::super::core::component::dex::v1::Position,
204 >,
205 #[prost(message, optional, tag = "4")]
207 pub note_record: ::core::option::Option<SpendableNoteRecord>,
208 #[prost(uint64, tag = "5")]
218 pub local_seq: u64,
219}
220impl ::prost::Name for AuctionsResponse {
221 const NAME: &'static str = "AuctionsResponse";
222 const PACKAGE: &'static str = "penumbra.view.v1";
223 fn full_name() -> ::prost::alloc::string::String {
224 "penumbra.view.v1.AuctionsResponse".into()
225 }
226 fn type_url() -> ::prost::alloc::string::String {
227 "/penumbra.view.v1.AuctionsResponse".into()
228 }
229}
230#[derive(Clone, PartialEq, ::prost::Message)]
231pub struct AuthorizeAndBuildRequest {
232 #[prost(message, optional, tag = "1")]
234 pub transaction_plan: ::core::option::Option<
235 super::super::core::transaction::v1::TransactionPlan,
236 >,
237}
238impl ::prost::Name for AuthorizeAndBuildRequest {
239 const NAME: &'static str = "AuthorizeAndBuildRequest";
240 const PACKAGE: &'static str = "penumbra.view.v1";
241 fn full_name() -> ::prost::alloc::string::String {
242 "penumbra.view.v1.AuthorizeAndBuildRequest".into()
243 }
244 fn type_url() -> ::prost::alloc::string::String {
245 "/penumbra.view.v1.AuthorizeAndBuildRequest".into()
246 }
247}
248#[derive(Clone, PartialEq, ::prost::Message)]
249pub struct AuthorizeAndBuildResponse {
250 #[prost(oneof = "authorize_and_build_response::Status", tags = "1, 2")]
251 pub status: ::core::option::Option<authorize_and_build_response::Status>,
252}
253pub mod authorize_and_build_response {
255 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
257 pub struct BuildProgress {
258 #[prost(float, tag = "1")]
260 pub progress: f32,
261 }
262 impl ::prost::Name for BuildProgress {
263 const NAME: &'static str = "BuildProgress";
264 const PACKAGE: &'static str = "penumbra.view.v1";
265 fn full_name() -> ::prost::alloc::string::String {
266 "penumbra.view.v1.AuthorizeAndBuildResponse.BuildProgress".into()
267 }
268 fn type_url() -> ::prost::alloc::string::String {
269 "/penumbra.view.v1.AuthorizeAndBuildResponse.BuildProgress".into()
270 }
271 }
272 #[derive(Clone, PartialEq, ::prost::Message)]
274 pub struct Complete {
275 #[prost(message, optional, tag = "1")]
277 pub transaction: ::core::option::Option<
278 super::super::super::core::transaction::v1::Transaction,
279 >,
280 }
281 impl ::prost::Name for Complete {
282 const NAME: &'static str = "Complete";
283 const PACKAGE: &'static str = "penumbra.view.v1";
284 fn full_name() -> ::prost::alloc::string::String {
285 "penumbra.view.v1.AuthorizeAndBuildResponse.Complete".into()
286 }
287 fn type_url() -> ::prost::alloc::string::String {
288 "/penumbra.view.v1.AuthorizeAndBuildResponse.Complete".into()
289 }
290 }
291 #[derive(Clone, PartialEq, ::prost::Oneof)]
292 pub enum Status {
293 #[prost(message, tag = "1")]
294 BuildProgress(BuildProgress),
295 #[prost(message, tag = "2")]
296 Complete(Complete),
297 }
298}
299impl ::prost::Name for AuthorizeAndBuildResponse {
300 const NAME: &'static str = "AuthorizeAndBuildResponse";
301 const PACKAGE: &'static str = "penumbra.view.v1";
302 fn full_name() -> ::prost::alloc::string::String {
303 "penumbra.view.v1.AuthorizeAndBuildResponse".into()
304 }
305 fn type_url() -> ::prost::alloc::string::String {
306 "/penumbra.view.v1.AuthorizeAndBuildResponse".into()
307 }
308}
309#[derive(Clone, PartialEq, ::prost::Message)]
310pub struct BroadcastTransactionRequest {
311 #[prost(message, optional, tag = "1")]
313 pub transaction: ::core::option::Option<
314 super::super::core::transaction::v1::Transaction,
315 >,
316 #[prost(bool, tag = "2")]
318 pub await_detection: bool,
319}
320impl ::prost::Name for BroadcastTransactionRequest {
321 const NAME: &'static str = "BroadcastTransactionRequest";
322 const PACKAGE: &'static str = "penumbra.view.v1";
323 fn full_name() -> ::prost::alloc::string::String {
324 "penumbra.view.v1.BroadcastTransactionRequest".into()
325 }
326 fn type_url() -> ::prost::alloc::string::String {
327 "/penumbra.view.v1.BroadcastTransactionRequest".into()
328 }
329}
330#[derive(Clone, PartialEq, ::prost::Message)]
331pub struct BroadcastTransactionResponse {
332 #[prost(oneof = "broadcast_transaction_response::Status", tags = "1, 2")]
333 pub status: ::core::option::Option<broadcast_transaction_response::Status>,
334}
335pub mod broadcast_transaction_response {
337 #[derive(Clone, PartialEq, ::prost::Message)]
339 pub struct BroadcastSuccess {
340 #[prost(message, optional, tag = "1")]
342 pub id: ::core::option::Option<
343 super::super::super::core::txhash::v1::TransactionId,
344 >,
345 }
346 impl ::prost::Name for BroadcastSuccess {
347 const NAME: &'static str = "BroadcastSuccess";
348 const PACKAGE: &'static str = "penumbra.view.v1";
349 fn full_name() -> ::prost::alloc::string::String {
350 "penumbra.view.v1.BroadcastTransactionResponse.BroadcastSuccess".into()
351 }
352 fn type_url() -> ::prost::alloc::string::String {
353 "/penumbra.view.v1.BroadcastTransactionResponse.BroadcastSuccess".into()
354 }
355 }
356 #[derive(Clone, PartialEq, ::prost::Message)]
360 pub struct Confirmed {
361 #[prost(message, optional, tag = "1")]
363 pub id: ::core::option::Option<
364 super::super::super::core::txhash::v1::TransactionId,
365 >,
366 #[prost(uint64, tag = "2")]
368 pub detection_height: u64,
369 }
370 impl ::prost::Name for Confirmed {
371 const NAME: &'static str = "Confirmed";
372 const PACKAGE: &'static str = "penumbra.view.v1";
373 fn full_name() -> ::prost::alloc::string::String {
374 "penumbra.view.v1.BroadcastTransactionResponse.Confirmed".into()
375 }
376 fn type_url() -> ::prost::alloc::string::String {
377 "/penumbra.view.v1.BroadcastTransactionResponse.Confirmed".into()
378 }
379 }
380 #[derive(Clone, PartialEq, ::prost::Oneof)]
381 pub enum Status {
382 #[prost(message, tag = "1")]
383 BroadcastSuccess(BroadcastSuccess),
384 #[prost(message, tag = "2")]
385 Confirmed(Confirmed),
386 }
387}
388impl ::prost::Name for BroadcastTransactionResponse {
389 const NAME: &'static str = "BroadcastTransactionResponse";
390 const PACKAGE: &'static str = "penumbra.view.v1";
391 fn full_name() -> ::prost::alloc::string::String {
392 "penumbra.view.v1.BroadcastTransactionResponse".into()
393 }
394 fn type_url() -> ::prost::alloc::string::String {
395 "/penumbra.view.v1.BroadcastTransactionResponse".into()
396 }
397}
398#[derive(Clone, PartialEq, ::prost::Message)]
399pub struct TransactionPlannerRequest {
400 #[prost(uint64, tag = "1")]
402 pub expiry_height: u64,
403 #[prost(message, optional, tag = "3")]
406 pub memo: ::core::option::Option<super::super::core::transaction::v1::MemoPlaintext>,
407 #[prost(message, optional, tag = "4")]
409 pub source: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
410 #[prost(message, repeated, tag = "20")]
412 pub outputs: ::prost::alloc::vec::Vec<transaction_planner_request::Output>,
413 #[prost(message, repeated, tag = "21")]
414 pub spends: ::prost::alloc::vec::Vec<transaction_planner_request::Spend>,
415 #[prost(message, repeated, tag = "30")]
416 pub swaps: ::prost::alloc::vec::Vec<transaction_planner_request::Swap>,
417 #[prost(message, repeated, tag = "31")]
418 pub swap_claims: ::prost::alloc::vec::Vec<transaction_planner_request::SwapClaim>,
419 #[prost(message, repeated, tag = "40")]
420 pub delegations: ::prost::alloc::vec::Vec<transaction_planner_request::Delegate>,
421 #[prost(message, repeated, tag = "50")]
422 pub undelegations: ::prost::alloc::vec::Vec<transaction_planner_request::Undelegate>,
423 #[prost(message, repeated, tag = "51")]
424 pub undelegation_claims: ::prost::alloc::vec::Vec<
425 transaction_planner_request::UndelegateClaim,
426 >,
427 #[prost(message, repeated, tag = "60")]
428 pub ibc_relay_actions: ::prost::alloc::vec::Vec<
429 super::super::core::component::ibc::v1::IbcRelay,
430 >,
431 #[prost(message, repeated, tag = "61")]
432 pub ics20_withdrawals: ::prost::alloc::vec::Vec<
433 super::super::core::component::ibc::v1::Ics20Withdrawal,
434 >,
435 #[prost(message, repeated, tag = "70")]
436 pub position_opens: ::prost::alloc::vec::Vec<
437 transaction_planner_request::PositionOpen,
438 >,
439 #[prost(message, repeated, tag = "71")]
440 pub position_closes: ::prost::alloc::vec::Vec<
441 transaction_planner_request::PositionClose,
442 >,
443 #[prost(message, repeated, tag = "72")]
444 pub position_withdraws: ::prost::alloc::vec::Vec<
445 transaction_planner_request::PositionWithdraw,
446 >,
447 #[prost(message, repeated, tag = "73")]
448 pub dutch_auction_schedule_actions: ::prost::alloc::vec::Vec<
449 transaction_planner_request::ActionDutchAuctionSchedule,
450 >,
451 #[prost(message, repeated, tag = "74")]
452 pub dutch_auction_end_actions: ::prost::alloc::vec::Vec<
453 transaction_planner_request::ActionDutchAuctionEnd,
454 >,
455 #[prost(message, repeated, tag = "75")]
456 pub dutch_auction_withdraw_actions: ::prost::alloc::vec::Vec<
457 transaction_planner_request::ActionDutchAuctionWithdraw,
458 >,
459 #[prost(message, repeated, tag = "76")]
460 pub delegator_votes: ::prost::alloc::vec::Vec<
461 transaction_planner_request::DelegatorVote,
462 >,
463 #[prost(message, repeated, tag = "77")]
464 pub action_liquidity_tournament_vote: ::prost::alloc::vec::Vec<
465 transaction_planner_request::ActionLiquidityTournamentVote,
466 >,
467 #[deprecated]
469 #[prost(uint64, tag = "200")]
470 pub epoch_index: u64,
471 #[prost(message, optional, tag = "201")]
473 pub epoch: ::core::option::Option<super::super::core::component::sct::v1::Epoch>,
474 #[prost(oneof = "transaction_planner_request::FeeMode", tags = "100, 101")]
476 pub fee_mode: ::core::option::Option<transaction_planner_request::FeeMode>,
477}
478pub mod transaction_planner_request {
480 #[derive(Clone, PartialEq, ::prost::Message)]
482 pub struct Output {
483 #[prost(message, optional, tag = "1")]
485 pub value: ::core::option::Option<super::super::super::core::asset::v1::Value>,
486 #[prost(message, optional, tag = "2")]
488 pub address: ::core::option::Option<
489 super::super::super::core::keys::v1::Address,
490 >,
491 }
492 impl ::prost::Name for Output {
493 const NAME: &'static str = "Output";
494 const PACKAGE: &'static str = "penumbra.view.v1";
495 fn full_name() -> ::prost::alloc::string::String {
496 "penumbra.view.v1.TransactionPlannerRequest.Output".into()
497 }
498 fn type_url() -> ::prost::alloc::string::String {
499 "/penumbra.view.v1.TransactionPlannerRequest.Output".into()
500 }
501 }
502 #[derive(Clone, PartialEq, ::prost::Message)]
503 pub struct Spend {
504 #[prost(message, optional, tag = "1")]
506 pub value: ::core::option::Option<super::super::super::core::asset::v1::Value>,
507 #[prost(message, optional, tag = "2")]
509 pub address: ::core::option::Option<
510 super::super::super::core::keys::v1::Address,
511 >,
512 }
513 impl ::prost::Name for Spend {
514 const NAME: &'static str = "Spend";
515 const PACKAGE: &'static str = "penumbra.view.v1";
516 fn full_name() -> ::prost::alloc::string::String {
517 "penumbra.view.v1.TransactionPlannerRequest.Spend".into()
518 }
519 fn type_url() -> ::prost::alloc::string::String {
520 "/penumbra.view.v1.TransactionPlannerRequest.Spend".into()
521 }
522 }
523 #[derive(Clone, PartialEq, ::prost::Message)]
524 pub struct Swap {
525 #[prost(message, optional, tag = "1")]
527 pub value: ::core::option::Option<super::super::super::core::asset::v1::Value>,
528 #[prost(message, optional, tag = "2")]
530 pub target_asset: ::core::option::Option<
531 super::super::super::core::asset::v1::AssetId,
532 >,
533 #[prost(message, optional, tag = "3")]
535 pub fee: ::core::option::Option<
536 super::super::super::core::component::fee::v1::Fee,
537 >,
538 #[prost(message, optional, tag = "4")]
540 pub claim_address: ::core::option::Option<
541 super::super::super::core::keys::v1::Address,
542 >,
543 }
544 impl ::prost::Name for Swap {
545 const NAME: &'static str = "Swap";
546 const PACKAGE: &'static str = "penumbra.view.v1";
547 fn full_name() -> ::prost::alloc::string::String {
548 "penumbra.view.v1.TransactionPlannerRequest.Swap".into()
549 }
550 fn type_url() -> ::prost::alloc::string::String {
551 "/penumbra.view.v1.TransactionPlannerRequest.Swap".into()
552 }
553 }
554 #[derive(Clone, PartialEq, ::prost::Message)]
555 pub struct SwapClaim {
556 #[prost(message, optional, tag = "1")]
560 pub swap_commitment: ::core::option::Option<
561 super::super::super::crypto::tct::v1::StateCommitment,
562 >,
563 }
564 impl ::prost::Name for SwapClaim {
565 const NAME: &'static str = "SwapClaim";
566 const PACKAGE: &'static str = "penumbra.view.v1";
567 fn full_name() -> ::prost::alloc::string::String {
568 "penumbra.view.v1.TransactionPlannerRequest.SwapClaim".into()
569 }
570 fn type_url() -> ::prost::alloc::string::String {
571 "/penumbra.view.v1.TransactionPlannerRequest.SwapClaim".into()
572 }
573 }
574 #[derive(Clone, PartialEq, ::prost::Message)]
575 pub struct Delegate {
576 #[prost(message, optional, tag = "1")]
577 pub amount: ::core::option::Option<super::super::super::core::num::v1::Amount>,
578 #[prost(message, optional, tag = "3")]
579 pub rate_data: ::core::option::Option<
580 super::super::super::core::component::stake::v1::RateData,
581 >,
582 }
583 impl ::prost::Name for Delegate {
584 const NAME: &'static str = "Delegate";
585 const PACKAGE: &'static str = "penumbra.view.v1";
586 fn full_name() -> ::prost::alloc::string::String {
587 "penumbra.view.v1.TransactionPlannerRequest.Delegate".into()
588 }
589 fn type_url() -> ::prost::alloc::string::String {
590 "/penumbra.view.v1.TransactionPlannerRequest.Delegate".into()
591 }
592 }
593 #[derive(Clone, PartialEq, ::prost::Message)]
594 pub struct Undelegate {
595 #[prost(message, optional, tag = "1")]
596 pub value: ::core::option::Option<super::super::super::core::asset::v1::Value>,
597 #[prost(message, optional, tag = "2")]
598 pub rate_data: ::core::option::Option<
599 super::super::super::core::component::stake::v1::RateData,
600 >,
601 }
602 impl ::prost::Name for Undelegate {
603 const NAME: &'static str = "Undelegate";
604 const PACKAGE: &'static str = "penumbra.view.v1";
605 fn full_name() -> ::prost::alloc::string::String {
606 "penumbra.view.v1.TransactionPlannerRequest.Undelegate".into()
607 }
608 fn type_url() -> ::prost::alloc::string::String {
609 "/penumbra.view.v1.TransactionPlannerRequest.Undelegate".into()
610 }
611 }
612 #[derive(Clone, PartialEq, ::prost::Message)]
613 pub struct UndelegateClaim {
614 #[prost(message, optional, tag = "1")]
616 pub validator_identity: ::core::option::Option<
617 super::super::super::core::keys::v1::IdentityKey,
618 >,
619 #[deprecated]
621 #[prost(uint64, tag = "2")]
622 pub start_epoch_index: u64,
623 #[prost(message, optional, tag = "3")]
626 pub penalty: ::core::option::Option<
627 super::super::super::core::component::stake::v1::Penalty,
628 >,
629 #[prost(message, optional, tag = "4")]
632 pub unbonding_amount: ::core::option::Option<
633 super::super::super::core::num::v1::Amount,
634 >,
635 #[prost(uint64, tag = "5")]
637 pub unbonding_start_height: u64,
638 }
639 impl ::prost::Name for UndelegateClaim {
640 const NAME: &'static str = "UndelegateClaim";
641 const PACKAGE: &'static str = "penumbra.view.v1";
642 fn full_name() -> ::prost::alloc::string::String {
643 "penumbra.view.v1.TransactionPlannerRequest.UndelegateClaim".into()
644 }
645 fn type_url() -> ::prost::alloc::string::String {
646 "/penumbra.view.v1.TransactionPlannerRequest.UndelegateClaim".into()
647 }
648 }
649 #[derive(Clone, PartialEq, ::prost::Message)]
650 pub struct PositionOpen {
651 #[prost(message, optional, tag = "1")]
656 pub position: ::core::option::Option<
657 super::super::super::core::component::dex::v1::Position,
658 >,
659 #[prost(message, optional, tag = "2")]
661 pub position_meta: ::core::option::Option<
662 super::super::super::core::component::dex::v1::PositionMetadata,
663 >,
664 }
665 impl ::prost::Name for PositionOpen {
666 const NAME: &'static str = "PositionOpen";
667 const PACKAGE: &'static str = "penumbra.view.v1";
668 fn full_name() -> ::prost::alloc::string::String {
669 "penumbra.view.v1.TransactionPlannerRequest.PositionOpen".into()
670 }
671 fn type_url() -> ::prost::alloc::string::String {
672 "/penumbra.view.v1.TransactionPlannerRequest.PositionOpen".into()
673 }
674 }
675 #[derive(Clone, PartialEq, ::prost::Message)]
676 pub struct PositionClose {
677 #[prost(message, optional, tag = "1")]
679 pub position_id: ::core::option::Option<
680 super::super::super::core::component::dex::v1::PositionId,
681 >,
682 }
683 impl ::prost::Name for PositionClose {
684 const NAME: &'static str = "PositionClose";
685 const PACKAGE: &'static str = "penumbra.view.v1";
686 fn full_name() -> ::prost::alloc::string::String {
687 "penumbra.view.v1.TransactionPlannerRequest.PositionClose".into()
688 }
689 fn type_url() -> ::prost::alloc::string::String {
690 "/penumbra.view.v1.TransactionPlannerRequest.PositionClose".into()
691 }
692 }
693 #[derive(Clone, PartialEq, ::prost::Message)]
694 pub struct PositionWithdraw {
695 #[prost(message, optional, tag = "1")]
697 pub position_id: ::core::option::Option<
698 super::super::super::core::component::dex::v1::PositionId,
699 >,
700 #[prost(message, optional, tag = "2")]
702 pub reserves: ::core::option::Option<
703 super::super::super::core::component::dex::v1::Reserves,
704 >,
705 #[prost(message, optional, tag = "3")]
707 pub trading_pair: ::core::option::Option<
708 super::super::super::core::component::dex::v1::TradingPair,
709 >,
710 }
711 impl ::prost::Name for PositionWithdraw {
712 const NAME: &'static str = "PositionWithdraw";
713 const PACKAGE: &'static str = "penumbra.view.v1";
714 fn full_name() -> ::prost::alloc::string::String {
715 "penumbra.view.v1.TransactionPlannerRequest.PositionWithdraw".into()
716 }
717 fn type_url() -> ::prost::alloc::string::String {
718 "/penumbra.view.v1.TransactionPlannerRequest.PositionWithdraw".into()
719 }
720 }
721 #[derive(Clone, PartialEq, ::prost::Message)]
722 pub struct ActionDutchAuctionSchedule {
723 #[prost(message, optional, tag = "1")]
725 pub description: ::core::option::Option<
726 super::super::super::core::component::auction::v1::DutchAuctionDescription,
727 >,
728 }
729 impl ::prost::Name for ActionDutchAuctionSchedule {
730 const NAME: &'static str = "ActionDutchAuctionSchedule";
731 const PACKAGE: &'static str = "penumbra.view.v1";
732 fn full_name() -> ::prost::alloc::string::String {
733 "penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionSchedule"
734 .into()
735 }
736 fn type_url() -> ::prost::alloc::string::String {
737 "/penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionSchedule"
738 .into()
739 }
740 }
741 #[derive(Clone, PartialEq, ::prost::Message)]
742 pub struct ActionDutchAuctionEnd {
743 #[prost(message, optional, tag = "1")]
745 pub auction_id: ::core::option::Option<
746 super::super::super::core::component::auction::v1::AuctionId,
747 >,
748 }
749 impl ::prost::Name for ActionDutchAuctionEnd {
750 const NAME: &'static str = "ActionDutchAuctionEnd";
751 const PACKAGE: &'static str = "penumbra.view.v1";
752 fn full_name() -> ::prost::alloc::string::String {
753 "penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionEnd".into()
754 }
755 fn type_url() -> ::prost::alloc::string::String {
756 "/penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionEnd".into()
757 }
758 }
759 #[derive(Clone, PartialEq, ::prost::Message)]
760 pub struct ActionDutchAuctionWithdraw {
761 #[prost(message, optional, tag = "1")]
763 pub auction_id: ::core::option::Option<
764 super::super::super::core::component::auction::v1::AuctionId,
765 >,
766 #[prost(uint64, tag = "2")]
768 pub seq: u64,
769 }
770 impl ::prost::Name for ActionDutchAuctionWithdraw {
771 const NAME: &'static str = "ActionDutchAuctionWithdraw";
772 const PACKAGE: &'static str = "penumbra.view.v1";
773 fn full_name() -> ::prost::alloc::string::String {
774 "penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionWithdraw"
775 .into()
776 }
777 fn type_url() -> ::prost::alloc::string::String {
778 "/penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionWithdraw"
779 .into()
780 }
781 }
782 #[derive(Clone, PartialEq, ::prost::Message)]
783 pub struct DelegatorVote {
784 #[prost(uint64, tag = "1")]
786 pub proposal: u64,
787 #[prost(message, optional, tag = "2")]
789 pub vote: ::core::option::Option<
790 super::super::super::core::component::governance::v1::Vote,
791 >,
792 #[prost(uint64, tag = "3")]
794 pub start_block_height: u64,
795 #[prost(uint64, tag = "4")]
797 pub start_position: u64,
798 #[prost(message, repeated, tag = "5")]
800 pub rate_data: ::prost::alloc::vec::Vec<
801 super::super::super::core::component::stake::v1::RateData,
802 >,
803 }
804 impl ::prost::Name for DelegatorVote {
805 const NAME: &'static str = "DelegatorVote";
806 const PACKAGE: &'static str = "penumbra.view.v1";
807 fn full_name() -> ::prost::alloc::string::String {
808 "penumbra.view.v1.TransactionPlannerRequest.DelegatorVote".into()
809 }
810 fn type_url() -> ::prost::alloc::string::String {
811 "/penumbra.view.v1.TransactionPlannerRequest.DelegatorVote".into()
812 }
813 }
814 #[derive(Clone, PartialEq, ::prost::Message)]
815 pub struct ActionLiquidityTournamentVote {
816 #[prost(message, optional, tag = "1")]
818 pub incentivized: ::core::option::Option<
819 super::super::super::core::asset::v1::Denom,
820 >,
821 #[prost(message, optional, tag = "2")]
823 pub rewards_recipient: ::core::option::Option<
824 super::super::super::core::keys::v1::Address,
825 >,
826 #[prost(message, repeated, tag = "3")]
828 pub staked_notes: ::prost::alloc::vec::Vec<super::SpendableNoteRecord>,
829 #[prost(uint64, tag = "4")]
831 pub epoch_index: u64,
832 }
833 impl ::prost::Name for ActionLiquidityTournamentVote {
834 const NAME: &'static str = "ActionLiquidityTournamentVote";
835 const PACKAGE: &'static str = "penumbra.view.v1";
836 fn full_name() -> ::prost::alloc::string::String {
837 "penumbra.view.v1.TransactionPlannerRequest.ActionLiquidityTournamentVote"
838 .into()
839 }
840 fn type_url() -> ::prost::alloc::string::String {
841 "/penumbra.view.v1.TransactionPlannerRequest.ActionLiquidityTournamentVote"
842 .into()
843 }
844 }
845 #[derive(Clone, PartialEq, ::prost::Oneof)]
847 pub enum FeeMode {
848 #[prost(message, tag = "100")]
850 AutoFee(super::super::super::core::component::fee::v1::FeeTier),
851 #[prost(message, tag = "101")]
853 ManualFee(super::super::super::core::component::fee::v1::Fee),
854 }
855}
856impl ::prost::Name for TransactionPlannerRequest {
857 const NAME: &'static str = "TransactionPlannerRequest";
858 const PACKAGE: &'static str = "penumbra.view.v1";
859 fn full_name() -> ::prost::alloc::string::String {
860 "penumbra.view.v1.TransactionPlannerRequest".into()
861 }
862 fn type_url() -> ::prost::alloc::string::String {
863 "/penumbra.view.v1.TransactionPlannerRequest".into()
864 }
865}
866#[derive(Clone, PartialEq, ::prost::Message)]
867pub struct TransactionPlannerResponse {
868 #[prost(message, optional, tag = "1")]
869 pub plan: ::core::option::Option<
870 super::super::core::transaction::v1::TransactionPlan,
871 >,
872}
873impl ::prost::Name for TransactionPlannerResponse {
874 const NAME: &'static str = "TransactionPlannerResponse";
875 const PACKAGE: &'static str = "penumbra.view.v1";
876 fn full_name() -> ::prost::alloc::string::String {
877 "penumbra.view.v1.TransactionPlannerResponse".into()
878 }
879 fn type_url() -> ::prost::alloc::string::String {
880 "/penumbra.view.v1.TransactionPlannerResponse".into()
881 }
882}
883#[derive(Clone, PartialEq, ::prost::Message)]
884pub struct AddressByIndexRequest {
885 #[prost(message, optional, tag = "1")]
886 pub address_index: ::core::option::Option<
887 super::super::core::keys::v1::AddressIndex,
888 >,
889}
890impl ::prost::Name for AddressByIndexRequest {
891 const NAME: &'static str = "AddressByIndexRequest";
892 const PACKAGE: &'static str = "penumbra.view.v1";
893 fn full_name() -> ::prost::alloc::string::String {
894 "penumbra.view.v1.AddressByIndexRequest".into()
895 }
896 fn type_url() -> ::prost::alloc::string::String {
897 "/penumbra.view.v1.AddressByIndexRequest".into()
898 }
899}
900#[derive(Clone, PartialEq, ::prost::Message)]
901pub struct AddressByIndexResponse {
902 #[prost(message, optional, tag = "1")]
903 pub address: ::core::option::Option<super::super::core::keys::v1::Address>,
904}
905impl ::prost::Name for AddressByIndexResponse {
906 const NAME: &'static str = "AddressByIndexResponse";
907 const PACKAGE: &'static str = "penumbra.view.v1";
908 fn full_name() -> ::prost::alloc::string::String {
909 "penumbra.view.v1.AddressByIndexResponse".into()
910 }
911 fn type_url() -> ::prost::alloc::string::String {
912 "/penumbra.view.v1.AddressByIndexResponse".into()
913 }
914}
915#[derive(Clone, Copy, PartialEq, ::prost::Message)]
916pub struct WalletIdRequest {}
917impl ::prost::Name for WalletIdRequest {
918 const NAME: &'static str = "WalletIdRequest";
919 const PACKAGE: &'static str = "penumbra.view.v1";
920 fn full_name() -> ::prost::alloc::string::String {
921 "penumbra.view.v1.WalletIdRequest".into()
922 }
923 fn type_url() -> ::prost::alloc::string::String {
924 "/penumbra.view.v1.WalletIdRequest".into()
925 }
926}
927#[derive(Clone, PartialEq, ::prost::Message)]
928pub struct WalletIdResponse {
929 #[prost(message, optional, tag = "1")]
930 pub wallet_id: ::core::option::Option<super::super::core::keys::v1::WalletId>,
931}
932impl ::prost::Name for WalletIdResponse {
933 const NAME: &'static str = "WalletIdResponse";
934 const PACKAGE: &'static str = "penumbra.view.v1";
935 fn full_name() -> ::prost::alloc::string::String {
936 "penumbra.view.v1.WalletIdResponse".into()
937 }
938 fn type_url() -> ::prost::alloc::string::String {
939 "/penumbra.view.v1.WalletIdResponse".into()
940 }
941}
942#[derive(Clone, PartialEq, ::prost::Message)]
943pub struct IndexByAddressRequest {
944 #[prost(message, optional, tag = "1")]
945 pub address: ::core::option::Option<super::super::core::keys::v1::Address>,
946}
947impl ::prost::Name for IndexByAddressRequest {
948 const NAME: &'static str = "IndexByAddressRequest";
949 const PACKAGE: &'static str = "penumbra.view.v1";
950 fn full_name() -> ::prost::alloc::string::String {
951 "penumbra.view.v1.IndexByAddressRequest".into()
952 }
953 fn type_url() -> ::prost::alloc::string::String {
954 "/penumbra.view.v1.IndexByAddressRequest".into()
955 }
956}
957#[derive(Clone, PartialEq, ::prost::Message)]
958pub struct IndexByAddressResponse {
959 #[prost(message, optional, tag = "1")]
961 pub address_index: ::core::option::Option<
962 super::super::core::keys::v1::AddressIndex,
963 >,
964}
965impl ::prost::Name for IndexByAddressResponse {
966 const NAME: &'static str = "IndexByAddressResponse";
967 const PACKAGE: &'static str = "penumbra.view.v1";
968 fn full_name() -> ::prost::alloc::string::String {
969 "penumbra.view.v1.IndexByAddressResponse".into()
970 }
971 fn type_url() -> ::prost::alloc::string::String {
972 "/penumbra.view.v1.IndexByAddressResponse".into()
973 }
974}
975#[derive(Clone, PartialEq, ::prost::Message)]
976pub struct EphemeralAddressRequest {
977 #[prost(message, optional, tag = "1")]
978 pub address_index: ::core::option::Option<
979 super::super::core::keys::v1::AddressIndex,
980 >,
981}
982impl ::prost::Name for EphemeralAddressRequest {
983 const NAME: &'static str = "EphemeralAddressRequest";
984 const PACKAGE: &'static str = "penumbra.view.v1";
985 fn full_name() -> ::prost::alloc::string::String {
986 "penumbra.view.v1.EphemeralAddressRequest".into()
987 }
988 fn type_url() -> ::prost::alloc::string::String {
989 "/penumbra.view.v1.EphemeralAddressRequest".into()
990 }
991}
992#[derive(Clone, PartialEq, ::prost::Message)]
993pub struct EphemeralAddressResponse {
994 #[prost(message, optional, tag = "1")]
995 pub address: ::core::option::Option<super::super::core::keys::v1::Address>,
996}
997impl ::prost::Name for EphemeralAddressResponse {
998 const NAME: &'static str = "EphemeralAddressResponse";
999 const PACKAGE: &'static str = "penumbra.view.v1";
1000 fn full_name() -> ::prost::alloc::string::String {
1001 "penumbra.view.v1.EphemeralAddressResponse".into()
1002 }
1003 fn type_url() -> ::prost::alloc::string::String {
1004 "/penumbra.view.v1.EphemeralAddressResponse".into()
1005 }
1006}
1007#[derive(Clone, PartialEq, ::prost::Message)]
1008pub struct BalancesRequest {
1009 #[prost(message, optional, tag = "1")]
1011 pub account_filter: ::core::option::Option<
1012 super::super::core::keys::v1::AddressIndex,
1013 >,
1014 #[prost(message, optional, tag = "2")]
1016 pub asset_id_filter: ::core::option::Option<super::super::core::asset::v1::AssetId>,
1017}
1018impl ::prost::Name for BalancesRequest {
1019 const NAME: &'static str = "BalancesRequest";
1020 const PACKAGE: &'static str = "penumbra.view.v1";
1021 fn full_name() -> ::prost::alloc::string::String {
1022 "penumbra.view.v1.BalancesRequest".into()
1023 }
1024 fn type_url() -> ::prost::alloc::string::String {
1025 "/penumbra.view.v1.BalancesRequest".into()
1026 }
1027}
1028#[derive(Clone, PartialEq, ::prost::Message)]
1029pub struct BalancesResponse {
1030 #[deprecated]
1032 #[prost(message, optional, tag = "1")]
1033 pub account: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
1034 #[deprecated]
1036 #[prost(message, optional, tag = "2")]
1037 pub balance: ::core::option::Option<super::super::core::asset::v1::Value>,
1038 #[prost(message, optional, tag = "3")]
1043 pub account_address: ::core::option::Option<
1044 super::super::core::keys::v1::AddressView,
1045 >,
1046 #[prost(message, optional, tag = "4")]
1048 pub balance_view: ::core::option::Option<super::super::core::asset::v1::ValueView>,
1049}
1050impl ::prost::Name for BalancesResponse {
1051 const NAME: &'static str = "BalancesResponse";
1052 const PACKAGE: &'static str = "penumbra.view.v1";
1053 fn full_name() -> ::prost::alloc::string::String {
1054 "penumbra.view.v1.BalancesResponse".into()
1055 }
1056 fn type_url() -> ::prost::alloc::string::String {
1057 "/penumbra.view.v1.BalancesResponse".into()
1058 }
1059}
1060#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1062pub struct StatusRequest {}
1063impl ::prost::Name for StatusRequest {
1064 const NAME: &'static str = "StatusRequest";
1065 const PACKAGE: &'static str = "penumbra.view.v1";
1066 fn full_name() -> ::prost::alloc::string::String {
1067 "penumbra.view.v1.StatusRequest".into()
1068 }
1069 fn type_url() -> ::prost::alloc::string::String {
1070 "/penumbra.view.v1.StatusRequest".into()
1071 }
1072}
1073#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1075pub struct StatusResponse {
1076 #[prost(uint64, tag = "1")]
1078 pub full_sync_height: u64,
1079 #[prost(uint64, tag = "2")]
1081 pub partial_sync_height: u64,
1082 #[prost(bool, tag = "3")]
1084 pub catching_up: bool,
1085}
1086impl ::prost::Name for StatusResponse {
1087 const NAME: &'static str = "StatusResponse";
1088 const PACKAGE: &'static str = "penumbra.view.v1";
1089 fn full_name() -> ::prost::alloc::string::String {
1090 "penumbra.view.v1.StatusResponse".into()
1091 }
1092 fn type_url() -> ::prost::alloc::string::String {
1093 "/penumbra.view.v1.StatusResponse".into()
1094 }
1095}
1096#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1098pub struct StatusStreamRequest {}
1099impl ::prost::Name for StatusStreamRequest {
1100 const NAME: &'static str = "StatusStreamRequest";
1101 const PACKAGE: &'static str = "penumbra.view.v1";
1102 fn full_name() -> ::prost::alloc::string::String {
1103 "penumbra.view.v1.StatusStreamRequest".into()
1104 }
1105 fn type_url() -> ::prost::alloc::string::String {
1106 "/penumbra.view.v1.StatusStreamRequest".into()
1107 }
1108}
1109#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1111pub struct StatusStreamResponse {
1112 #[prost(uint64, tag = "1")]
1114 pub latest_known_block_height: u64,
1115 #[prost(uint64, tag = "2")]
1117 pub full_sync_height: u64,
1118 #[prost(uint64, tag = "3")]
1120 pub partial_sync_height: u64,
1121}
1122impl ::prost::Name for StatusStreamResponse {
1123 const NAME: &'static str = "StatusStreamResponse";
1124 const PACKAGE: &'static str = "penumbra.view.v1";
1125 fn full_name() -> ::prost::alloc::string::String {
1126 "penumbra.view.v1.StatusStreamResponse".into()
1127 }
1128 fn type_url() -> ::prost::alloc::string::String {
1129 "/penumbra.view.v1.StatusStreamResponse".into()
1130 }
1131}
1132#[derive(Clone, PartialEq, ::prost::Message)]
1137pub struct NotesRequest {
1138 #[prost(bool, tag = "2")]
1140 pub include_spent: bool,
1141 #[prost(message, optional, tag = "3")]
1143 pub asset_id: ::core::option::Option<super::super::core::asset::v1::AssetId>,
1144 #[prost(message, optional, tag = "4")]
1146 pub address_index: ::core::option::Option<
1147 super::super::core::keys::v1::AddressIndex,
1148 >,
1149 #[prost(message, optional, tag = "6")]
1153 pub amount_to_spend: ::core::option::Option<super::super::core::num::v1::Amount>,
1154}
1155impl ::prost::Name for NotesRequest {
1156 const NAME: &'static str = "NotesRequest";
1157 const PACKAGE: &'static str = "penumbra.view.v1";
1158 fn full_name() -> ::prost::alloc::string::String {
1159 "penumbra.view.v1.NotesRequest".into()
1160 }
1161 fn type_url() -> ::prost::alloc::string::String {
1162 "/penumbra.view.v1.NotesRequest".into()
1163 }
1164}
1165#[derive(Clone, PartialEq, ::prost::Message)]
1167pub struct NotesForVotingRequest {
1168 #[prost(uint64, tag = "1")]
1170 pub votable_at_height: u64,
1171 #[prost(message, optional, tag = "3")]
1173 pub address_index: ::core::option::Option<
1174 super::super::core::keys::v1::AddressIndex,
1175 >,
1176}
1177impl ::prost::Name for NotesForVotingRequest {
1178 const NAME: &'static str = "NotesForVotingRequest";
1179 const PACKAGE: &'static str = "penumbra.view.v1";
1180 fn full_name() -> ::prost::alloc::string::String {
1181 "penumbra.view.v1.NotesForVotingRequest".into()
1182 }
1183 fn type_url() -> ::prost::alloc::string::String {
1184 "/penumbra.view.v1.NotesForVotingRequest".into()
1185 }
1186}
1187#[derive(Clone, PartialEq, ::prost::Message)]
1188pub struct WitnessRequest {
1189 #[prost(message, optional, tag = "3")]
1191 pub transaction_plan: ::core::option::Option<
1192 super::super::core::transaction::v1::TransactionPlan,
1193 >,
1194}
1195impl ::prost::Name for WitnessRequest {
1196 const NAME: &'static str = "WitnessRequest";
1197 const PACKAGE: &'static str = "penumbra.view.v1";
1198 fn full_name() -> ::prost::alloc::string::String {
1199 "penumbra.view.v1.WitnessRequest".into()
1200 }
1201 fn type_url() -> ::prost::alloc::string::String {
1202 "/penumbra.view.v1.WitnessRequest".into()
1203 }
1204}
1205#[derive(Clone, PartialEq, ::prost::Message)]
1206pub struct WitnessResponse {
1207 #[prost(message, optional, tag = "1")]
1208 pub witness_data: ::core::option::Option<
1209 super::super::core::transaction::v1::WitnessData,
1210 >,
1211}
1212impl ::prost::Name for WitnessResponse {
1213 const NAME: &'static str = "WitnessResponse";
1214 const PACKAGE: &'static str = "penumbra.view.v1";
1215 fn full_name() -> ::prost::alloc::string::String {
1216 "penumbra.view.v1.WitnessResponse".into()
1217 }
1218 fn type_url() -> ::prost::alloc::string::String {
1219 "/penumbra.view.v1.WitnessResponse".into()
1220 }
1221}
1222#[derive(Clone, PartialEq, ::prost::Message)]
1223pub struct WitnessAndBuildRequest {
1224 #[prost(message, optional, tag = "1")]
1225 pub transaction_plan: ::core::option::Option<
1226 super::super::core::transaction::v1::TransactionPlan,
1227 >,
1228 #[prost(message, optional, tag = "2")]
1229 pub authorization_data: ::core::option::Option<
1230 super::super::core::transaction::v1::AuthorizationData,
1231 >,
1232}
1233impl ::prost::Name for WitnessAndBuildRequest {
1234 const NAME: &'static str = "WitnessAndBuildRequest";
1235 const PACKAGE: &'static str = "penumbra.view.v1";
1236 fn full_name() -> ::prost::alloc::string::String {
1237 "penumbra.view.v1.WitnessAndBuildRequest".into()
1238 }
1239 fn type_url() -> ::prost::alloc::string::String {
1240 "/penumbra.view.v1.WitnessAndBuildRequest".into()
1241 }
1242}
1243#[derive(Clone, PartialEq, ::prost::Message)]
1244pub struct WitnessAndBuildResponse {
1245 #[prost(oneof = "witness_and_build_response::Status", tags = "1, 2")]
1246 pub status: ::core::option::Option<witness_and_build_response::Status>,
1247}
1248pub mod witness_and_build_response {
1250 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
1252 pub struct BuildProgress {
1253 #[prost(float, tag = "1")]
1255 pub progress: f32,
1256 }
1257 impl ::prost::Name for BuildProgress {
1258 const NAME: &'static str = "BuildProgress";
1259 const PACKAGE: &'static str = "penumbra.view.v1";
1260 fn full_name() -> ::prost::alloc::string::String {
1261 "penumbra.view.v1.WitnessAndBuildResponse.BuildProgress".into()
1262 }
1263 fn type_url() -> ::prost::alloc::string::String {
1264 "/penumbra.view.v1.WitnessAndBuildResponse.BuildProgress".into()
1265 }
1266 }
1267 #[derive(Clone, PartialEq, ::prost::Message)]
1269 pub struct Complete {
1270 #[prost(message, optional, tag = "1")]
1272 pub transaction: ::core::option::Option<
1273 super::super::super::core::transaction::v1::Transaction,
1274 >,
1275 }
1276 impl ::prost::Name for Complete {
1277 const NAME: &'static str = "Complete";
1278 const PACKAGE: &'static str = "penumbra.view.v1";
1279 fn full_name() -> ::prost::alloc::string::String {
1280 "penumbra.view.v1.WitnessAndBuildResponse.Complete".into()
1281 }
1282 fn type_url() -> ::prost::alloc::string::String {
1283 "/penumbra.view.v1.WitnessAndBuildResponse.Complete".into()
1284 }
1285 }
1286 #[derive(Clone, PartialEq, ::prost::Oneof)]
1287 pub enum Status {
1288 #[prost(message, tag = "1")]
1289 BuildProgress(BuildProgress),
1290 #[prost(message, tag = "2")]
1291 Complete(Complete),
1292 }
1293}
1294impl ::prost::Name for WitnessAndBuildResponse {
1295 const NAME: &'static str = "WitnessAndBuildResponse";
1296 const PACKAGE: &'static str = "penumbra.view.v1";
1297 fn full_name() -> ::prost::alloc::string::String {
1298 "penumbra.view.v1.WitnessAndBuildResponse".into()
1299 }
1300 fn type_url() -> ::prost::alloc::string::String {
1301 "/penumbra.view.v1.WitnessAndBuildResponse".into()
1302 }
1303}
1304#[derive(Clone, PartialEq, ::prost::Message)]
1306pub struct AssetsRequest {
1307 #[prost(bool, tag = "1")]
1310 pub filtered: bool,
1311 #[prost(message, repeated, tag = "2")]
1313 pub include_specific_denominations: ::prost::alloc::vec::Vec<
1314 super::super::core::asset::v1::Denom,
1315 >,
1316 #[prost(bool, tag = "3")]
1318 pub include_delegation_tokens: bool,
1319 #[prost(bool, tag = "4")]
1321 pub include_unbonding_tokens: bool,
1322 #[prost(bool, tag = "5")]
1324 pub include_lp_nfts: bool,
1325 #[prost(bool, tag = "6")]
1327 pub include_proposal_nfts: bool,
1328 #[prost(bool, tag = "7")]
1330 pub include_voting_receipt_tokens: bool,
1331}
1332impl ::prost::Name for AssetsRequest {
1333 const NAME: &'static str = "AssetsRequest";
1334 const PACKAGE: &'static str = "penumbra.view.v1";
1335 fn full_name() -> ::prost::alloc::string::String {
1336 "penumbra.view.v1.AssetsRequest".into()
1337 }
1338 fn type_url() -> ::prost::alloc::string::String {
1339 "/penumbra.view.v1.AssetsRequest".into()
1340 }
1341}
1342#[derive(Clone, PartialEq, ::prost::Message)]
1344pub struct AssetsResponse {
1345 #[prost(message, optional, tag = "2")]
1346 pub denom_metadata: ::core::option::Option<super::super::core::asset::v1::Metadata>,
1347}
1348impl ::prost::Name for AssetsResponse {
1349 const NAME: &'static str = "AssetsResponse";
1350 const PACKAGE: &'static str = "penumbra.view.v1";
1351 fn full_name() -> ::prost::alloc::string::String {
1352 "penumbra.view.v1.AssetsResponse".into()
1353 }
1354 fn type_url() -> ::prost::alloc::string::String {
1355 "/penumbra.view.v1.AssetsResponse".into()
1356 }
1357}
1358#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1360pub struct AppParametersRequest {}
1361impl ::prost::Name for AppParametersRequest {
1362 const NAME: &'static str = "AppParametersRequest";
1363 const PACKAGE: &'static str = "penumbra.view.v1";
1364 fn full_name() -> ::prost::alloc::string::String {
1365 "penumbra.view.v1.AppParametersRequest".into()
1366 }
1367 fn type_url() -> ::prost::alloc::string::String {
1368 "/penumbra.view.v1.AppParametersRequest".into()
1369 }
1370}
1371#[derive(Clone, PartialEq, ::prost::Message)]
1372pub struct AppParametersResponse {
1373 #[prost(message, optional, tag = "1")]
1374 pub parameters: ::core::option::Option<super::super::core::app::v1::AppParameters>,
1375}
1376impl ::prost::Name for AppParametersResponse {
1377 const NAME: &'static str = "AppParametersResponse";
1378 const PACKAGE: &'static str = "penumbra.view.v1";
1379 fn full_name() -> ::prost::alloc::string::String {
1380 "penumbra.view.v1.AppParametersResponse".into()
1381 }
1382 fn type_url() -> ::prost::alloc::string::String {
1383 "/penumbra.view.v1.AppParametersResponse".into()
1384 }
1385}
1386#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1388pub struct GasPricesRequest {}
1389impl ::prost::Name for GasPricesRequest {
1390 const NAME: &'static str = "GasPricesRequest";
1391 const PACKAGE: &'static str = "penumbra.view.v1";
1392 fn full_name() -> ::prost::alloc::string::String {
1393 "penumbra.view.v1.GasPricesRequest".into()
1394 }
1395 fn type_url() -> ::prost::alloc::string::String {
1396 "/penumbra.view.v1.GasPricesRequest".into()
1397 }
1398}
1399#[derive(Clone, PartialEq, ::prost::Message)]
1400pub struct GasPricesResponse {
1401 #[prost(message, optional, tag = "1")]
1403 pub gas_prices: ::core::option::Option<
1404 super::super::core::component::fee::v1::GasPrices,
1405 >,
1406 #[prost(message, repeated, tag = "2")]
1408 pub alt_gas_prices: ::prost::alloc::vec::Vec<
1409 super::super::core::component::fee::v1::GasPrices,
1410 >,
1411}
1412impl ::prost::Name for GasPricesResponse {
1413 const NAME: &'static str = "GasPricesResponse";
1414 const PACKAGE: &'static str = "penumbra.view.v1";
1415 fn full_name() -> ::prost::alloc::string::String {
1416 "penumbra.view.v1.GasPricesResponse".into()
1417 }
1418 fn type_url() -> ::prost::alloc::string::String {
1419 "/penumbra.view.v1.GasPricesResponse".into()
1420 }
1421}
1422#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1424pub struct FmdParametersRequest {}
1425impl ::prost::Name for FmdParametersRequest {
1426 const NAME: &'static str = "FMDParametersRequest";
1427 const PACKAGE: &'static str = "penumbra.view.v1";
1428 fn full_name() -> ::prost::alloc::string::String {
1429 "penumbra.view.v1.FMDParametersRequest".into()
1430 }
1431 fn type_url() -> ::prost::alloc::string::String {
1432 "/penumbra.view.v1.FMDParametersRequest".into()
1433 }
1434}
1435#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1436pub struct FmdParametersResponse {
1437 #[prost(message, optional, tag = "1")]
1438 pub parameters: ::core::option::Option<
1439 super::super::core::component::shielded_pool::v1::FmdParameters,
1440 >,
1441}
1442impl ::prost::Name for FmdParametersResponse {
1443 const NAME: &'static str = "FMDParametersResponse";
1444 const PACKAGE: &'static str = "penumbra.view.v1";
1445 fn full_name() -> ::prost::alloc::string::String {
1446 "penumbra.view.v1.FMDParametersResponse".into()
1447 }
1448 fn type_url() -> ::prost::alloc::string::String {
1449 "/penumbra.view.v1.FMDParametersResponse".into()
1450 }
1451}
1452#[derive(Clone, PartialEq, ::prost::Message)]
1453pub struct NoteByCommitmentRequest {
1454 #[prost(message, optional, tag = "2")]
1455 pub note_commitment: ::core::option::Option<
1456 super::super::crypto::tct::v1::StateCommitment,
1457 >,
1458 #[prost(bool, tag = "3")]
1460 pub await_detection: bool,
1461}
1462impl ::prost::Name for NoteByCommitmentRequest {
1463 const NAME: &'static str = "NoteByCommitmentRequest";
1464 const PACKAGE: &'static str = "penumbra.view.v1";
1465 fn full_name() -> ::prost::alloc::string::String {
1466 "penumbra.view.v1.NoteByCommitmentRequest".into()
1467 }
1468 fn type_url() -> ::prost::alloc::string::String {
1469 "/penumbra.view.v1.NoteByCommitmentRequest".into()
1470 }
1471}
1472#[derive(Clone, PartialEq, ::prost::Message)]
1473pub struct NoteByCommitmentResponse {
1474 #[prost(message, optional, tag = "1")]
1475 pub spendable_note: ::core::option::Option<SpendableNoteRecord>,
1476}
1477impl ::prost::Name for NoteByCommitmentResponse {
1478 const NAME: &'static str = "NoteByCommitmentResponse";
1479 const PACKAGE: &'static str = "penumbra.view.v1";
1480 fn full_name() -> ::prost::alloc::string::String {
1481 "penumbra.view.v1.NoteByCommitmentResponse".into()
1482 }
1483 fn type_url() -> ::prost::alloc::string::String {
1484 "/penumbra.view.v1.NoteByCommitmentResponse".into()
1485 }
1486}
1487#[derive(Clone, PartialEq, ::prost::Message)]
1488pub struct SwapByCommitmentRequest {
1489 #[prost(message, optional, tag = "2")]
1490 pub swap_commitment: ::core::option::Option<
1491 super::super::crypto::tct::v1::StateCommitment,
1492 >,
1493 #[prost(bool, tag = "3")]
1495 pub await_detection: bool,
1496}
1497impl ::prost::Name for SwapByCommitmentRequest {
1498 const NAME: &'static str = "SwapByCommitmentRequest";
1499 const PACKAGE: &'static str = "penumbra.view.v1";
1500 fn full_name() -> ::prost::alloc::string::String {
1501 "penumbra.view.v1.SwapByCommitmentRequest".into()
1502 }
1503 fn type_url() -> ::prost::alloc::string::String {
1504 "/penumbra.view.v1.SwapByCommitmentRequest".into()
1505 }
1506}
1507#[derive(Clone, PartialEq, ::prost::Message)]
1508pub struct SwapByCommitmentResponse {
1509 #[prost(message, optional, tag = "1")]
1510 pub swap: ::core::option::Option<SwapRecord>,
1511}
1512impl ::prost::Name for SwapByCommitmentResponse {
1513 const NAME: &'static str = "SwapByCommitmentResponse";
1514 const PACKAGE: &'static str = "penumbra.view.v1";
1515 fn full_name() -> ::prost::alloc::string::String {
1516 "penumbra.view.v1.SwapByCommitmentResponse".into()
1517 }
1518 fn type_url() -> ::prost::alloc::string::String {
1519 "/penumbra.view.v1.SwapByCommitmentResponse".into()
1520 }
1521}
1522#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1523pub struct UnclaimedSwapsRequest {}
1524impl ::prost::Name for UnclaimedSwapsRequest {
1525 const NAME: &'static str = "UnclaimedSwapsRequest";
1526 const PACKAGE: &'static str = "penumbra.view.v1";
1527 fn full_name() -> ::prost::alloc::string::String {
1528 "penumbra.view.v1.UnclaimedSwapsRequest".into()
1529 }
1530 fn type_url() -> ::prost::alloc::string::String {
1531 "/penumbra.view.v1.UnclaimedSwapsRequest".into()
1532 }
1533}
1534#[derive(Clone, PartialEq, ::prost::Message)]
1535pub struct UnclaimedSwapsResponse {
1536 #[prost(message, optional, tag = "1")]
1537 pub swap: ::core::option::Option<SwapRecord>,
1538}
1539impl ::prost::Name for UnclaimedSwapsResponse {
1540 const NAME: &'static str = "UnclaimedSwapsResponse";
1541 const PACKAGE: &'static str = "penumbra.view.v1";
1542 fn full_name() -> ::prost::alloc::string::String {
1543 "penumbra.view.v1.UnclaimedSwapsResponse".into()
1544 }
1545 fn type_url() -> ::prost::alloc::string::String {
1546 "/penumbra.view.v1.UnclaimedSwapsResponse".into()
1547 }
1548}
1549#[derive(Clone, PartialEq, ::prost::Message)]
1550pub struct NullifierStatusRequest {
1551 #[prost(message, optional, tag = "2")]
1552 pub nullifier: ::core::option::Option<
1553 super::super::core::component::sct::v1::Nullifier,
1554 >,
1555 #[prost(bool, tag = "3")]
1556 pub await_detection: bool,
1557}
1558impl ::prost::Name for NullifierStatusRequest {
1559 const NAME: &'static str = "NullifierStatusRequest";
1560 const PACKAGE: &'static str = "penumbra.view.v1";
1561 fn full_name() -> ::prost::alloc::string::String {
1562 "penumbra.view.v1.NullifierStatusRequest".into()
1563 }
1564 fn type_url() -> ::prost::alloc::string::String {
1565 "/penumbra.view.v1.NullifierStatusRequest".into()
1566 }
1567}
1568#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1569pub struct NullifierStatusResponse {
1570 #[prost(bool, tag = "1")]
1571 pub spent: bool,
1572}
1573impl ::prost::Name for NullifierStatusResponse {
1574 const NAME: &'static str = "NullifierStatusResponse";
1575 const PACKAGE: &'static str = "penumbra.view.v1";
1576 fn full_name() -> ::prost::alloc::string::String {
1577 "penumbra.view.v1.NullifierStatusResponse".into()
1578 }
1579 fn type_url() -> ::prost::alloc::string::String {
1580 "/penumbra.view.v1.NullifierStatusResponse".into()
1581 }
1582}
1583#[derive(Clone, PartialEq, ::prost::Message)]
1584pub struct TransactionInfoByHashRequest {
1585 #[prost(message, optional, tag = "2")]
1587 pub id: ::core::option::Option<super::super::core::txhash::v1::TransactionId>,
1588}
1589impl ::prost::Name for TransactionInfoByHashRequest {
1590 const NAME: &'static str = "TransactionInfoByHashRequest";
1591 const PACKAGE: &'static str = "penumbra.view.v1";
1592 fn full_name() -> ::prost::alloc::string::String {
1593 "penumbra.view.v1.TransactionInfoByHashRequest".into()
1594 }
1595 fn type_url() -> ::prost::alloc::string::String {
1596 "/penumbra.view.v1.TransactionInfoByHashRequest".into()
1597 }
1598}
1599#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1600pub struct TransactionInfoRequest {
1601 #[prost(uint64, tag = "1")]
1603 pub start_height: u64,
1604 #[prost(uint64, tag = "2")]
1606 pub end_height: u64,
1607}
1608impl ::prost::Name for TransactionInfoRequest {
1609 const NAME: &'static str = "TransactionInfoRequest";
1610 const PACKAGE: &'static str = "penumbra.view.v1";
1611 fn full_name() -> ::prost::alloc::string::String {
1612 "penumbra.view.v1.TransactionInfoRequest".into()
1613 }
1614 fn type_url() -> ::prost::alloc::string::String {
1615 "/penumbra.view.v1.TransactionInfoRequest".into()
1616 }
1617}
1618#[derive(Clone, PartialEq, ::prost::Message)]
1619pub struct TransactionInfo {
1620 #[prost(uint64, tag = "1")]
1622 pub height: u64,
1623 #[prost(message, optional, tag = "2")]
1625 pub id: ::core::option::Option<super::super::core::txhash::v1::TransactionId>,
1626 #[prost(message, optional, tag = "3")]
1628 pub transaction: ::core::option::Option<
1629 super::super::core::transaction::v1::Transaction,
1630 >,
1631 #[prost(message, optional, tag = "4")]
1633 pub perspective: ::core::option::Option<
1634 super::super::core::transaction::v1::TransactionPerspective,
1635 >,
1636 #[prost(message, optional, tag = "5")]
1638 pub view: ::core::option::Option<
1639 super::super::core::transaction::v1::TransactionView,
1640 >,
1641 #[prost(message, optional, tag = "6")]
1643 pub summary: ::core::option::Option<
1644 super::super::core::transaction::v1::TransactionSummary,
1645 >,
1646}
1647impl ::prost::Name for TransactionInfo {
1648 const NAME: &'static str = "TransactionInfo";
1649 const PACKAGE: &'static str = "penumbra.view.v1";
1650 fn full_name() -> ::prost::alloc::string::String {
1651 "penumbra.view.v1.TransactionInfo".into()
1652 }
1653 fn type_url() -> ::prost::alloc::string::String {
1654 "/penumbra.view.v1.TransactionInfo".into()
1655 }
1656}
1657#[derive(Clone, PartialEq, ::prost::Message)]
1658pub struct TransactionInfoResponse {
1659 #[prost(message, optional, tag = "1")]
1660 pub tx_info: ::core::option::Option<TransactionInfo>,
1661}
1662impl ::prost::Name for TransactionInfoResponse {
1663 const NAME: &'static str = "TransactionInfoResponse";
1664 const PACKAGE: &'static str = "penumbra.view.v1";
1665 fn full_name() -> ::prost::alloc::string::String {
1666 "penumbra.view.v1.TransactionInfoResponse".into()
1667 }
1668 fn type_url() -> ::prost::alloc::string::String {
1669 "/penumbra.view.v1.TransactionInfoResponse".into()
1670 }
1671}
1672#[derive(Clone, PartialEq, ::prost::Message)]
1673pub struct TransactionInfoByHashResponse {
1674 #[prost(message, optional, tag = "1")]
1675 pub tx_info: ::core::option::Option<TransactionInfo>,
1676}
1677impl ::prost::Name for TransactionInfoByHashResponse {
1678 const NAME: &'static str = "TransactionInfoByHashResponse";
1679 const PACKAGE: &'static str = "penumbra.view.v1";
1680 fn full_name() -> ::prost::alloc::string::String {
1681 "penumbra.view.v1.TransactionInfoByHashResponse".into()
1682 }
1683 fn type_url() -> ::prost::alloc::string::String {
1684 "/penumbra.view.v1.TransactionInfoByHashResponse".into()
1685 }
1686}
1687#[derive(Clone, PartialEq, ::prost::Message)]
1688pub struct NotesResponse {
1689 #[prost(message, optional, tag = "1")]
1690 pub note_record: ::core::option::Option<SpendableNoteRecord>,
1691}
1692impl ::prost::Name for NotesResponse {
1693 const NAME: &'static str = "NotesResponse";
1694 const PACKAGE: &'static str = "penumbra.view.v1";
1695 fn full_name() -> ::prost::alloc::string::String {
1696 "penumbra.view.v1.NotesResponse".into()
1697 }
1698 fn type_url() -> ::prost::alloc::string::String {
1699 "/penumbra.view.v1.NotesResponse".into()
1700 }
1701}
1702#[derive(Clone, PartialEq, ::prost::Message)]
1703pub struct NotesForVotingResponse {
1704 #[prost(message, optional, tag = "1")]
1705 pub note_record: ::core::option::Option<SpendableNoteRecord>,
1706 #[prost(message, optional, tag = "2")]
1707 pub identity_key: ::core::option::Option<super::super::core::keys::v1::IdentityKey>,
1708}
1709impl ::prost::Name for NotesForVotingResponse {
1710 const NAME: &'static str = "NotesForVotingResponse";
1711 const PACKAGE: &'static str = "penumbra.view.v1";
1712 fn full_name() -> ::prost::alloc::string::String {
1713 "penumbra.view.v1.NotesForVotingResponse".into()
1714 }
1715 fn type_url() -> ::prost::alloc::string::String {
1716 "/penumbra.view.v1.NotesForVotingResponse".into()
1717 }
1718}
1719#[derive(Clone, PartialEq, ::prost::Message)]
1721pub struct SpendableNoteRecord {
1722 #[prost(message, optional, tag = "1")]
1724 pub note_commitment: ::core::option::Option<
1725 super::super::crypto::tct::v1::StateCommitment,
1726 >,
1727 #[prost(message, optional, tag = "2")]
1729 pub note: ::core::option::Option<
1730 super::super::core::component::shielded_pool::v1::Note,
1731 >,
1732 #[prost(message, optional, tag = "3")]
1734 pub address_index: ::core::option::Option<
1735 super::super::core::keys::v1::AddressIndex,
1736 >,
1737 #[prost(message, optional, tag = "4")]
1739 pub nullifier: ::core::option::Option<
1740 super::super::core::component::sct::v1::Nullifier,
1741 >,
1742 #[prost(uint64, tag = "5")]
1744 pub height_created: u64,
1745 #[prost(uint64, tag = "6")]
1747 pub height_spent: u64,
1748 #[prost(uint64, tag = "7")]
1750 pub position: u64,
1751 #[prost(message, optional, tag = "8")]
1753 pub source: ::core::option::Option<
1754 super::super::core::component::sct::v1::CommitmentSource,
1755 >,
1756 #[prost(message, optional, tag = "9")]
1758 pub return_address: ::core::option::Option<
1759 super::super::core::keys::v1::AddressView,
1760 >,
1761}
1762impl ::prost::Name for SpendableNoteRecord {
1763 const NAME: &'static str = "SpendableNoteRecord";
1764 const PACKAGE: &'static str = "penumbra.view.v1";
1765 fn full_name() -> ::prost::alloc::string::String {
1766 "penumbra.view.v1.SpendableNoteRecord".into()
1767 }
1768 fn type_url() -> ::prost::alloc::string::String {
1769 "/penumbra.view.v1.SpendableNoteRecord".into()
1770 }
1771}
1772#[derive(Clone, PartialEq, ::prost::Message)]
1773pub struct SwapRecord {
1774 #[prost(message, optional, tag = "1")]
1775 pub swap_commitment: ::core::option::Option<
1776 super::super::crypto::tct::v1::StateCommitment,
1777 >,
1778 #[prost(message, optional, tag = "2")]
1779 pub swap: ::core::option::Option<
1780 super::super::core::component::dex::v1::SwapPlaintext,
1781 >,
1782 #[prost(uint64, tag = "3")]
1783 pub position: u64,
1784 #[prost(message, optional, tag = "4")]
1785 pub nullifier: ::core::option::Option<
1786 super::super::core::component::sct::v1::Nullifier,
1787 >,
1788 #[prost(message, optional, tag = "5")]
1789 pub output_data: ::core::option::Option<
1790 super::super::core::component::dex::v1::BatchSwapOutputData,
1791 >,
1792 #[prost(uint64, tag = "6")]
1793 pub height_claimed: u64,
1794 #[prost(message, optional, tag = "7")]
1795 pub source: ::core::option::Option<
1796 super::super::core::component::sct::v1::CommitmentSource,
1797 >,
1798}
1799impl ::prost::Name for SwapRecord {
1800 const NAME: &'static str = "SwapRecord";
1801 const PACKAGE: &'static str = "penumbra.view.v1";
1802 fn full_name() -> ::prost::alloc::string::String {
1803 "penumbra.view.v1.SwapRecord".into()
1804 }
1805 fn type_url() -> ::prost::alloc::string::String {
1806 "/penumbra.view.v1.SwapRecord".into()
1807 }
1808}
1809#[derive(Clone, PartialEq, ::prost::Message)]
1810pub struct OwnedPositionIdsRequest {
1811 #[prost(message, optional, tag = "1")]
1813 pub position_state: ::core::option::Option<
1814 super::super::core::component::dex::v1::PositionState,
1815 >,
1816 #[prost(message, optional, tag = "2")]
1818 pub trading_pair: ::core::option::Option<
1819 super::super::core::component::dex::v1::TradingPair,
1820 >,
1821 #[prost(message, optional, tag = "3")]
1823 pub subaccount: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
1824}
1825impl ::prost::Name for OwnedPositionIdsRequest {
1826 const NAME: &'static str = "OwnedPositionIdsRequest";
1827 const PACKAGE: &'static str = "penumbra.view.v1";
1828 fn full_name() -> ::prost::alloc::string::String {
1829 "penumbra.view.v1.OwnedPositionIdsRequest".into()
1830 }
1831 fn type_url() -> ::prost::alloc::string::String {
1832 "/penumbra.view.v1.OwnedPositionIdsRequest".into()
1833 }
1834}
1835#[derive(Clone, PartialEq, ::prost::Message)]
1836pub struct OwnedPositionIdsResponse {
1837 #[prost(message, optional, tag = "1")]
1838 pub position_id: ::core::option::Option<
1839 super::super::core::component::dex::v1::PositionId,
1840 >,
1841 #[prost(message, optional, tag = "2")]
1843 pub subaccount: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
1844}
1845impl ::prost::Name for OwnedPositionIdsResponse {
1846 const NAME: &'static str = "OwnedPositionIdsResponse";
1847 const PACKAGE: &'static str = "penumbra.view.v1";
1848 fn full_name() -> ::prost::alloc::string::String {
1849 "penumbra.view.v1.OwnedPositionIdsResponse".into()
1850 }
1851 fn type_url() -> ::prost::alloc::string::String {
1852 "/penumbra.view.v1.OwnedPositionIdsResponse".into()
1853 }
1854}
1855#[derive(Clone, PartialEq, ::prost::Message)]
1857pub struct AssetMetadataByIdRequest {
1858 #[prost(message, optional, tag = "2")]
1860 pub asset_id: ::core::option::Option<super::super::core::asset::v1::AssetId>,
1861}
1862impl ::prost::Name for AssetMetadataByIdRequest {
1863 const NAME: &'static str = "AssetMetadataByIdRequest";
1864 const PACKAGE: &'static str = "penumbra.view.v1";
1865 fn full_name() -> ::prost::alloc::string::String {
1866 "penumbra.view.v1.AssetMetadataByIdRequest".into()
1867 }
1868 fn type_url() -> ::prost::alloc::string::String {
1869 "/penumbra.view.v1.AssetMetadataByIdRequest".into()
1870 }
1871}
1872#[derive(Clone, PartialEq, ::prost::Message)]
1873pub struct AssetMetadataByIdResponse {
1874 #[prost(message, optional, tag = "1")]
1878 pub denom_metadata: ::core::option::Option<super::super::core::asset::v1::Metadata>,
1879}
1880impl ::prost::Name for AssetMetadataByIdResponse {
1881 const NAME: &'static str = "AssetMetadataByIdResponse";
1882 const PACKAGE: &'static str = "penumbra.view.v1";
1883 fn full_name() -> ::prost::alloc::string::String {
1884 "penumbra.view.v1.AssetMetadataByIdResponse".into()
1885 }
1886 fn type_url() -> ::prost::alloc::string::String {
1887 "/penumbra.view.v1.AssetMetadataByIdResponse".into()
1888 }
1889}
1890#[derive(Clone, PartialEq, ::prost::Message)]
1894pub struct DelegationsByAddressIndexRequest {
1895 #[prost(message, optional, tag = "1")]
1897 pub address_index: ::core::option::Option<
1898 super::super::core::keys::v1::AddressIndex,
1899 >,
1900 #[prost(enumeration = "delegations_by_address_index_request::Filter", tag = "2")]
1901 pub filter: i32,
1902}
1903pub mod delegations_by_address_index_request {
1905 #[derive(
1906 Clone,
1907 Copy,
1908 Debug,
1909 PartialEq,
1910 Eq,
1911 Hash,
1912 PartialOrd,
1913 Ord,
1914 ::prost::Enumeration
1915 )]
1916 #[repr(i32)]
1917 pub enum Filter {
1918 Unspecified = 0,
1922 AllActiveWithNonzeroBalances = 1,
1925 All = 2,
1929 }
1930 impl Filter {
1931 pub fn as_str_name(&self) -> &'static str {
1936 match self {
1937 Self::Unspecified => "FILTER_UNSPECIFIED",
1938 Self::AllActiveWithNonzeroBalances => {
1939 "FILTER_ALL_ACTIVE_WITH_NONZERO_BALANCES"
1940 }
1941 Self::All => "FILTER_ALL",
1942 }
1943 }
1944 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1946 match value {
1947 "FILTER_UNSPECIFIED" => Some(Self::Unspecified),
1948 "FILTER_ALL_ACTIVE_WITH_NONZERO_BALANCES" => {
1949 Some(Self::AllActiveWithNonzeroBalances)
1950 }
1951 "FILTER_ALL" => Some(Self::All),
1952 _ => None,
1953 }
1954 }
1955 }
1956}
1957impl ::prost::Name for DelegationsByAddressIndexRequest {
1958 const NAME: &'static str = "DelegationsByAddressIndexRequest";
1959 const PACKAGE: &'static str = "penumbra.view.v1";
1960 fn full_name() -> ::prost::alloc::string::String {
1961 "penumbra.view.v1.DelegationsByAddressIndexRequest".into()
1962 }
1963 fn type_url() -> ::prost::alloc::string::String {
1964 "/penumbra.view.v1.DelegationsByAddressIndexRequest".into()
1965 }
1966}
1967#[derive(Clone, PartialEq, ::prost::Message)]
1971pub struct DelegationsByAddressIndexResponse {
1972 #[prost(message, optional, tag = "1")]
1973 pub value_view: ::core::option::Option<super::super::core::asset::v1::ValueView>,
1974}
1975impl ::prost::Name for DelegationsByAddressIndexResponse {
1976 const NAME: &'static str = "DelegationsByAddressIndexResponse";
1977 const PACKAGE: &'static str = "penumbra.view.v1";
1978 fn full_name() -> ::prost::alloc::string::String {
1979 "penumbra.view.v1.DelegationsByAddressIndexResponse".into()
1980 }
1981 fn type_url() -> ::prost::alloc::string::String {
1982 "/penumbra.view.v1.DelegationsByAddressIndexResponse".into()
1983 }
1984}
1985#[derive(Clone, PartialEq, ::prost::Message)]
1988pub struct UnbondingTokensByAddressIndexRequest {
1989 #[prost(
1990 enumeration = "unbonding_tokens_by_address_index_request::Filter",
1991 tag = "1"
1992 )]
1993 pub filter: i32,
1994 #[prost(message, optional, tag = "2")]
1996 pub address_index: ::core::option::Option<
1997 super::super::core::keys::v1::AddressIndex,
1998 >,
1999}
2000pub mod unbonding_tokens_by_address_index_request {
2002 #[derive(
2003 Clone,
2004 Copy,
2005 Debug,
2006 PartialEq,
2007 Eq,
2008 Hash,
2009 PartialOrd,
2010 Ord,
2011 ::prost::Enumeration
2012 )]
2013 #[repr(i32)]
2014 pub enum Filter {
2015 Unspecified = 0,
2018 Claimable = 1,
2023 NotYetClaimable = 2,
2026 }
2027 impl Filter {
2028 pub fn as_str_name(&self) -> &'static str {
2033 match self {
2034 Self::Unspecified => "FILTER_UNSPECIFIED",
2035 Self::Claimable => "FILTER_CLAIMABLE",
2036 Self::NotYetClaimable => "FILTER_NOT_YET_CLAIMABLE",
2037 }
2038 }
2039 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2041 match value {
2042 "FILTER_UNSPECIFIED" => Some(Self::Unspecified),
2043 "FILTER_CLAIMABLE" => Some(Self::Claimable),
2044 "FILTER_NOT_YET_CLAIMABLE" => Some(Self::NotYetClaimable),
2045 _ => None,
2046 }
2047 }
2048 }
2049}
2050impl ::prost::Name for UnbondingTokensByAddressIndexRequest {
2051 const NAME: &'static str = "UnbondingTokensByAddressIndexRequest";
2052 const PACKAGE: &'static str = "penumbra.view.v1";
2053 fn full_name() -> ::prost::alloc::string::String {
2054 "penumbra.view.v1.UnbondingTokensByAddressIndexRequest".into()
2055 }
2056 fn type_url() -> ::prost::alloc::string::String {
2057 "/penumbra.view.v1.UnbondingTokensByAddressIndexRequest".into()
2058 }
2059}
2060#[derive(Clone, PartialEq, ::prost::Message)]
2063pub struct UnbondingTokensByAddressIndexResponse {
2064 #[prost(message, optional, tag = "1")]
2066 pub value_view: ::core::option::Option<super::super::core::asset::v1::ValueView>,
2067 #[prost(bool, tag = "2")]
2071 pub claimable: bool,
2072}
2073impl ::prost::Name for UnbondingTokensByAddressIndexResponse {
2074 const NAME: &'static str = "UnbondingTokensByAddressIndexResponse";
2075 const PACKAGE: &'static str = "penumbra.view.v1";
2076 fn full_name() -> ::prost::alloc::string::String {
2077 "penumbra.view.v1.UnbondingTokensByAddressIndexResponse".into()
2078 }
2079 fn type_url() -> ::prost::alloc::string::String {
2080 "/penumbra.view.v1.UnbondingTokensByAddressIndexResponse".into()
2081 }
2082}
2083#[derive(Clone, PartialEq, ::prost::Message)]
2085pub struct LatestSwapsRequest {
2086 #[prost(message, optional, tag = "1")]
2088 pub account_filter: ::core::option::Option<
2089 super::super::core::keys::v1::AddressIndex,
2090 >,
2091 #[prost(message, optional, tag = "2")]
2093 pub pair: ::core::option::Option<
2094 super::super::core::component::dex::v1::DirectedTradingPair,
2095 >,
2096 #[prost(uint64, tag = "3")]
2098 pub after_height: u64,
2099 #[prost(uint64, tag = "4")]
2101 pub response_limit: u64,
2102}
2103impl ::prost::Name for LatestSwapsRequest {
2104 const NAME: &'static str = "LatestSwapsRequest";
2105 const PACKAGE: &'static str = "penumbra.view.v1";
2106 fn full_name() -> ::prost::alloc::string::String {
2107 "penumbra.view.v1.LatestSwapsRequest".into()
2108 }
2109 fn type_url() -> ::prost::alloc::string::String {
2110 "/penumbra.view.v1.LatestSwapsRequest".into()
2111 }
2112}
2113#[derive(Clone, PartialEq, ::prost::Message)]
2114pub struct LatestSwapsResponse {
2115 #[prost(message, optional, tag = "1")]
2117 pub pair: ::core::option::Option<
2118 super::super::core::component::dex::v1::DirectedTradingPair,
2119 >,
2120 #[prost(message, optional, tag = "2")]
2122 pub input: ::core::option::Option<super::super::core::asset::v1::Value>,
2123 #[prost(message, optional, tag = "3")]
2125 pub output: ::core::option::Option<super::super::core::asset::v1::Value>,
2126 #[prost(uint64, tag = "4")]
2128 pub block_height: u64,
2129 #[prost(message, optional, tag = "5")]
2131 pub id: ::core::option::Option<super::super::core::txhash::v1::TransactionId>,
2132}
2133impl ::prost::Name for LatestSwapsResponse {
2134 const NAME: &'static str = "LatestSwapsResponse";
2135 const PACKAGE: &'static str = "penumbra.view.v1";
2136 fn full_name() -> ::prost::alloc::string::String {
2137 "penumbra.view.v1.LatestSwapsResponse".into()
2138 }
2139 fn type_url() -> ::prost::alloc::string::String {
2140 "/penumbra.view.v1.LatestSwapsResponse".into()
2141 }
2142}
2143#[derive(Clone, PartialEq, ::prost::Message)]
2145pub struct LpPositionBundleRequest {
2146 #[prost(message, optional, tag = "1")]
2148 pub subaccount: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
2149 #[prost(message, optional, tag = "2")]
2151 pub trading_pair: ::core::option::Option<
2152 super::super::core::component::dex::v1::TradingPair,
2153 >,
2154 #[prost(message, optional, tag = "3")]
2156 pub position_metadata: ::core::option::Option<
2157 super::super::core::component::dex::v1::PositionMetadata,
2158 >,
2159 #[prost(message, optional, tag = "4")]
2161 pub position_state: ::core::option::Option<
2162 super::super::core::component::dex::v1::PositionState,
2163 >,
2164}
2165impl ::prost::Name for LpPositionBundleRequest {
2166 const NAME: &'static str = "LpPositionBundleRequest";
2167 const PACKAGE: &'static str = "penumbra.view.v1";
2168 fn full_name() -> ::prost::alloc::string::String {
2169 "penumbra.view.v1.LpPositionBundleRequest".into()
2170 }
2171 fn type_url() -> ::prost::alloc::string::String {
2172 "/penumbra.view.v1.LpPositionBundleRequest".into()
2173 }
2174}
2175#[derive(Clone, PartialEq, ::prost::Message)]
2176pub struct LpPositionBundleResponse {
2177 #[prost(message, repeated, tag = "1")]
2178 pub entries: ::prost::alloc::vec::Vec<lp_position_bundle_response::Entry>,
2179}
2180pub mod lp_position_bundle_response {
2182 #[derive(Clone, PartialEq, ::prost::Message)]
2183 pub struct Entry {
2184 #[prost(message, optional, tag = "1")]
2186 pub trading_pair: ::core::option::Option<
2187 super::super::super::core::component::dex::v1::TradingPair,
2188 >,
2189 #[prost(message, optional, tag = "2")]
2191 pub subaccount: ::core::option::Option<
2192 super::super::super::core::keys::v1::AddressIndex,
2193 >,
2194 #[prost(message, optional, tag = "3")]
2196 pub position_metadata: ::core::option::Option<
2197 super::super::super::core::component::dex::v1::PositionMetadata,
2198 >,
2199 #[prost(message, optional, tag = "4")]
2201 pub position_state: ::core::option::Option<
2202 super::super::super::core::component::dex::v1::PositionState,
2203 >,
2204 #[prost(message, repeated, tag = "5")]
2206 pub position_id: ::prost::alloc::vec::Vec<
2207 super::super::super::core::component::dex::v1::PositionId,
2208 >,
2209 }
2210 impl ::prost::Name for Entry {
2211 const NAME: &'static str = "Entry";
2212 const PACKAGE: &'static str = "penumbra.view.v1";
2213 fn full_name() -> ::prost::alloc::string::String {
2214 "penumbra.view.v1.LpPositionBundleResponse.Entry".into()
2215 }
2216 fn type_url() -> ::prost::alloc::string::String {
2217 "/penumbra.view.v1.LpPositionBundleResponse.Entry".into()
2218 }
2219 }
2220}
2221impl ::prost::Name for LpPositionBundleResponse {
2222 const NAME: &'static str = "LpPositionBundleResponse";
2223 const PACKAGE: &'static str = "penumbra.view.v1";
2224 fn full_name() -> ::prost::alloc::string::String {
2225 "penumbra.view.v1.LpPositionBundleResponse".into()
2226 }
2227 fn type_url() -> ::prost::alloc::string::String {
2228 "/penumbra.view.v1.LpPositionBundleResponse".into()
2229 }
2230}
2231#[derive(Clone, PartialEq, ::prost::Message)]
2233pub struct LpStrategyCatalogRequest {
2234 #[prost(message, optional, tag = "1")]
2236 pub subaccount: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
2237 #[prost(message, optional, tag = "2")]
2239 pub trading_pair: ::core::option::Option<
2240 super::super::core::component::dex::v1::TradingPair,
2241 >,
2242 #[prost(message, optional, tag = "3")]
2244 pub position_metadata: ::core::option::Option<
2245 super::super::core::component::dex::v1::PositionMetadata,
2246 >,
2247}
2248impl ::prost::Name for LpStrategyCatalogRequest {
2249 const NAME: &'static str = "LpStrategyCatalogRequest";
2250 const PACKAGE: &'static str = "penumbra.view.v1";
2251 fn full_name() -> ::prost::alloc::string::String {
2252 "penumbra.view.v1.LpStrategyCatalogRequest".into()
2253 }
2254 fn type_url() -> ::prost::alloc::string::String {
2255 "/penumbra.view.v1.LpStrategyCatalogRequest".into()
2256 }
2257}
2258#[derive(Clone, PartialEq, ::prost::Message)]
2259pub struct LpStrategyCatalogResponse {
2260 #[prost(message, repeated, tag = "1")]
2261 pub strategies: ::prost::alloc::vec::Vec<
2262 lp_strategy_catalog_response::StrategyEntry,
2263 >,
2264}
2265pub mod lp_strategy_catalog_response {
2267 #[derive(Clone, PartialEq, ::prost::Message)]
2268 pub struct StrategyEntry {
2269 #[prost(message, optional, tag = "1")]
2271 pub trading_pair: ::core::option::Option<
2272 super::super::super::core::component::dex::v1::TradingPair,
2273 >,
2274 #[prost(message, optional, tag = "2")]
2276 pub subaccount: ::core::option::Option<
2277 super::super::super::core::keys::v1::AddressIndex,
2278 >,
2279 #[prost(message, optional, tag = "3")]
2281 pub position_metadata: ::core::option::Option<
2282 super::super::super::core::component::dex::v1::PositionMetadata,
2283 >,
2284 }
2285 impl ::prost::Name for StrategyEntry {
2286 const NAME: &'static str = "StrategyEntry";
2287 const PACKAGE: &'static str = "penumbra.view.v1";
2288 fn full_name() -> ::prost::alloc::string::String {
2289 "penumbra.view.v1.LpStrategyCatalogResponse.StrategyEntry".into()
2290 }
2291 fn type_url() -> ::prost::alloc::string::String {
2292 "/penumbra.view.v1.LpStrategyCatalogResponse.StrategyEntry".into()
2293 }
2294 }
2295}
2296impl ::prost::Name for LpStrategyCatalogResponse {
2297 const NAME: &'static str = "LpStrategyCatalogResponse";
2298 const PACKAGE: &'static str = "penumbra.view.v1";
2299 fn full_name() -> ::prost::alloc::string::String {
2300 "penumbra.view.v1.LpStrategyCatalogResponse".into()
2301 }
2302 fn type_url() -> ::prost::alloc::string::String {
2303 "/penumbra.view.v1.LpStrategyCatalogResponse".into()
2304 }
2305}
2306#[cfg(feature = "rpc")]
2308pub mod view_service_client {
2309 #![allow(
2310 unused_variables,
2311 dead_code,
2312 missing_docs,
2313 clippy::wildcard_imports,
2314 clippy::let_unit_value,
2315 )]
2316 use tonic::codegen::*;
2317 use tonic::codegen::http::Uri;
2318 #[derive(Debug, Clone)]
2323 pub struct ViewServiceClient<T> {
2324 inner: tonic::client::Grpc<T>,
2325 }
2326 impl ViewServiceClient<tonic::transport::Channel> {
2327 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
2329 where
2330 D: TryInto<tonic::transport::Endpoint>,
2331 D::Error: Into<StdError>,
2332 {
2333 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
2334 Ok(Self::new(conn))
2335 }
2336 }
2337 impl<T> ViewServiceClient<T>
2338 where
2339 T: tonic::client::GrpcService<tonic::body::BoxBody>,
2340 T::Error: Into<StdError>,
2341 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
2342 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
2343 {
2344 pub fn new(inner: T) -> Self {
2345 let inner = tonic::client::Grpc::new(inner);
2346 Self { inner }
2347 }
2348 pub fn with_origin(inner: T, origin: Uri) -> Self {
2349 let inner = tonic::client::Grpc::with_origin(inner, origin);
2350 Self { inner }
2351 }
2352 pub fn with_interceptor<F>(
2353 inner: T,
2354 interceptor: F,
2355 ) -> ViewServiceClient<InterceptedService<T, F>>
2356 where
2357 F: tonic::service::Interceptor,
2358 T::ResponseBody: Default,
2359 T: tonic::codegen::Service<
2360 http::Request<tonic::body::BoxBody>,
2361 Response = http::Response<
2362 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
2363 >,
2364 >,
2365 <T as tonic::codegen::Service<
2366 http::Request<tonic::body::BoxBody>,
2367 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
2368 {
2369 ViewServiceClient::new(InterceptedService::new(inner, interceptor))
2370 }
2371 #[must_use]
2376 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2377 self.inner = self.inner.send_compressed(encoding);
2378 self
2379 }
2380 #[must_use]
2382 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2383 self.inner = self.inner.accept_compressed(encoding);
2384 self
2385 }
2386 #[must_use]
2390 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2391 self.inner = self.inner.max_decoding_message_size(limit);
2392 self
2393 }
2394 #[must_use]
2398 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2399 self.inner = self.inner.max_encoding_message_size(limit);
2400 self
2401 }
2402 pub async fn status(
2404 &mut self,
2405 request: impl tonic::IntoRequest<super::StatusRequest>,
2406 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> {
2407 self.inner
2408 .ready()
2409 .await
2410 .map_err(|e| {
2411 tonic::Status::unknown(
2412 format!("Service was not ready: {}", e.into()),
2413 )
2414 })?;
2415 let codec = tonic::codec::ProstCodec::default();
2416 let path = http::uri::PathAndQuery::from_static(
2417 "/penumbra.view.v1.ViewService/Status",
2418 );
2419 let mut req = request.into_request();
2420 req.extensions_mut()
2421 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "Status"));
2422 self.inner.unary(req, path, codec).await
2423 }
2424 pub async fn status_stream(
2427 &mut self,
2428 request: impl tonic::IntoRequest<super::StatusStreamRequest>,
2429 ) -> std::result::Result<
2430 tonic::Response<tonic::codec::Streaming<super::StatusStreamResponse>>,
2431 tonic::Status,
2432 > {
2433 self.inner
2434 .ready()
2435 .await
2436 .map_err(|e| {
2437 tonic::Status::unknown(
2438 format!("Service was not ready: {}", e.into()),
2439 )
2440 })?;
2441 let codec = tonic::codec::ProstCodec::default();
2442 let path = http::uri::PathAndQuery::from_static(
2443 "/penumbra.view.v1.ViewService/StatusStream",
2444 );
2445 let mut req = request.into_request();
2446 req.extensions_mut()
2447 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "StatusStream"));
2448 self.inner.server_streaming(req, path, codec).await
2449 }
2450 pub async fn notes(
2453 &mut self,
2454 request: impl tonic::IntoRequest<super::NotesRequest>,
2455 ) -> std::result::Result<
2456 tonic::Response<tonic::codec::Streaming<super::NotesResponse>>,
2457 tonic::Status,
2458 > {
2459 self.inner
2460 .ready()
2461 .await
2462 .map_err(|e| {
2463 tonic::Status::unknown(
2464 format!("Service was not ready: {}", e.into()),
2465 )
2466 })?;
2467 let codec = tonic::codec::ProstCodec::default();
2468 let path = http::uri::PathAndQuery::from_static(
2469 "/penumbra.view.v1.ViewService/Notes",
2470 );
2471 let mut req = request.into_request();
2472 req.extensions_mut()
2473 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "Notes"));
2474 self.inner.server_streaming(req, path, codec).await
2475 }
2476 pub async fn notes_for_voting(
2478 &mut self,
2479 request: impl tonic::IntoRequest<super::NotesForVotingRequest>,
2480 ) -> std::result::Result<
2481 tonic::Response<tonic::codec::Streaming<super::NotesForVotingResponse>>,
2482 tonic::Status,
2483 > {
2484 self.inner
2485 .ready()
2486 .await
2487 .map_err(|e| {
2488 tonic::Status::unknown(
2489 format!("Service was not ready: {}", e.into()),
2490 )
2491 })?;
2492 let codec = tonic::codec::ProstCodec::default();
2493 let path = http::uri::PathAndQuery::from_static(
2494 "/penumbra.view.v1.ViewService/NotesForVoting",
2495 );
2496 let mut req = request.into_request();
2497 req.extensions_mut()
2498 .insert(
2499 GrpcMethod::new("penumbra.view.v1.ViewService", "NotesForVoting"),
2500 );
2501 self.inner.server_streaming(req, path, codec).await
2502 }
2503 pub async fn assets(
2506 &mut self,
2507 request: impl tonic::IntoRequest<super::AssetsRequest>,
2508 ) -> std::result::Result<
2509 tonic::Response<tonic::codec::Streaming<super::AssetsResponse>>,
2510 tonic::Status,
2511 > {
2512 self.inner
2513 .ready()
2514 .await
2515 .map_err(|e| {
2516 tonic::Status::unknown(
2517 format!("Service was not ready: {}", e.into()),
2518 )
2519 })?;
2520 let codec = tonic::codec::ProstCodec::default();
2521 let path = http::uri::PathAndQuery::from_static(
2522 "/penumbra.view.v1.ViewService/Assets",
2523 );
2524 let mut req = request.into_request();
2525 req.extensions_mut()
2526 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "Assets"));
2527 self.inner.server_streaming(req, path, codec).await
2528 }
2529 pub async fn asset_metadata_by_id(
2535 &mut self,
2536 request: impl tonic::IntoRequest<super::AssetMetadataByIdRequest>,
2537 ) -> std::result::Result<
2538 tonic::Response<super::AssetMetadataByIdResponse>,
2539 tonic::Status,
2540 > {
2541 self.inner
2542 .ready()
2543 .await
2544 .map_err(|e| {
2545 tonic::Status::unknown(
2546 format!("Service was not ready: {}", e.into()),
2547 )
2548 })?;
2549 let codec = tonic::codec::ProstCodec::default();
2550 let path = http::uri::PathAndQuery::from_static(
2551 "/penumbra.view.v1.ViewService/AssetMetadataById",
2552 );
2553 let mut req = request.into_request();
2554 req.extensions_mut()
2555 .insert(
2556 GrpcMethod::new("penumbra.view.v1.ViewService", "AssetMetadataById"),
2557 );
2558 self.inner.unary(req, path, codec).await
2559 }
2560 pub async fn app_parameters(
2562 &mut self,
2563 request: impl tonic::IntoRequest<super::AppParametersRequest>,
2564 ) -> std::result::Result<
2565 tonic::Response<super::AppParametersResponse>,
2566 tonic::Status,
2567 > {
2568 self.inner
2569 .ready()
2570 .await
2571 .map_err(|e| {
2572 tonic::Status::unknown(
2573 format!("Service was not ready: {}", e.into()),
2574 )
2575 })?;
2576 let codec = tonic::codec::ProstCodec::default();
2577 let path = http::uri::PathAndQuery::from_static(
2578 "/penumbra.view.v1.ViewService/AppParameters",
2579 );
2580 let mut req = request.into_request();
2581 req.extensions_mut()
2582 .insert(
2583 GrpcMethod::new("penumbra.view.v1.ViewService", "AppParameters"),
2584 );
2585 self.inner.unary(req, path, codec).await
2586 }
2587 pub async fn gas_prices(
2589 &mut self,
2590 request: impl tonic::IntoRequest<super::GasPricesRequest>,
2591 ) -> std::result::Result<
2592 tonic::Response<super::GasPricesResponse>,
2593 tonic::Status,
2594 > {
2595 self.inner
2596 .ready()
2597 .await
2598 .map_err(|e| {
2599 tonic::Status::unknown(
2600 format!("Service was not ready: {}", e.into()),
2601 )
2602 })?;
2603 let codec = tonic::codec::ProstCodec::default();
2604 let path = http::uri::PathAndQuery::from_static(
2605 "/penumbra.view.v1.ViewService/GasPrices",
2606 );
2607 let mut req = request.into_request();
2608 req.extensions_mut()
2609 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "GasPrices"));
2610 self.inner.unary(req, path, codec).await
2611 }
2612 pub async fn fmd_parameters(
2614 &mut self,
2615 request: impl tonic::IntoRequest<super::FmdParametersRequest>,
2616 ) -> std::result::Result<
2617 tonic::Response<super::FmdParametersResponse>,
2618 tonic::Status,
2619 > {
2620 self.inner
2621 .ready()
2622 .await
2623 .map_err(|e| {
2624 tonic::Status::unknown(
2625 format!("Service was not ready: {}", e.into()),
2626 )
2627 })?;
2628 let codec = tonic::codec::ProstCodec::default();
2629 let path = http::uri::PathAndQuery::from_static(
2630 "/penumbra.view.v1.ViewService/FMDParameters",
2631 );
2632 let mut req = request.into_request();
2633 req.extensions_mut()
2634 .insert(
2635 GrpcMethod::new("penumbra.view.v1.ViewService", "FMDParameters"),
2636 );
2637 self.inner.unary(req, path, codec).await
2638 }
2639 pub async fn address_by_index(
2641 &mut self,
2642 request: impl tonic::IntoRequest<super::AddressByIndexRequest>,
2643 ) -> std::result::Result<
2644 tonic::Response<super::AddressByIndexResponse>,
2645 tonic::Status,
2646 > {
2647 self.inner
2648 .ready()
2649 .await
2650 .map_err(|e| {
2651 tonic::Status::unknown(
2652 format!("Service was not ready: {}", e.into()),
2653 )
2654 })?;
2655 let codec = tonic::codec::ProstCodec::default();
2656 let path = http::uri::PathAndQuery::from_static(
2657 "/penumbra.view.v1.ViewService/AddressByIndex",
2658 );
2659 let mut req = request.into_request();
2660 req.extensions_mut()
2661 .insert(
2662 GrpcMethod::new("penumbra.view.v1.ViewService", "AddressByIndex"),
2663 );
2664 self.inner.unary(req, path, codec).await
2665 }
2666 pub async fn transparent_address(
2668 &mut self,
2669 request: impl tonic::IntoRequest<super::TransparentAddressRequest>,
2670 ) -> std::result::Result<
2671 tonic::Response<super::TransparentAddressResponse>,
2672 tonic::Status,
2673 > {
2674 self.inner
2675 .ready()
2676 .await
2677 .map_err(|e| {
2678 tonic::Status::unknown(
2679 format!("Service was not ready: {}", e.into()),
2680 )
2681 })?;
2682 let codec = tonic::codec::ProstCodec::default();
2683 let path = http::uri::PathAndQuery::from_static(
2684 "/penumbra.view.v1.ViewService/TransparentAddress",
2685 );
2686 let mut req = request.into_request();
2687 req.extensions_mut()
2688 .insert(
2689 GrpcMethod::new("penumbra.view.v1.ViewService", "TransparentAddress"),
2690 );
2691 self.inner.unary(req, path, codec).await
2692 }
2693 pub async fn wallet_id(
2695 &mut self,
2696 request: impl tonic::IntoRequest<super::WalletIdRequest>,
2697 ) -> std::result::Result<
2698 tonic::Response<super::WalletIdResponse>,
2699 tonic::Status,
2700 > {
2701 self.inner
2702 .ready()
2703 .await
2704 .map_err(|e| {
2705 tonic::Status::unknown(
2706 format!("Service was not ready: {}", e.into()),
2707 )
2708 })?;
2709 let codec = tonic::codec::ProstCodec::default();
2710 let path = http::uri::PathAndQuery::from_static(
2711 "/penumbra.view.v1.ViewService/WalletId",
2712 );
2713 let mut req = request.into_request();
2714 req.extensions_mut()
2715 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "WalletId"));
2716 self.inner.unary(req, path, codec).await
2717 }
2718 pub async fn index_by_address(
2720 &mut self,
2721 request: impl tonic::IntoRequest<super::IndexByAddressRequest>,
2722 ) -> std::result::Result<
2723 tonic::Response<super::IndexByAddressResponse>,
2724 tonic::Status,
2725 > {
2726 self.inner
2727 .ready()
2728 .await
2729 .map_err(|e| {
2730 tonic::Status::unknown(
2731 format!("Service was not ready: {}", e.into()),
2732 )
2733 })?;
2734 let codec = tonic::codec::ProstCodec::default();
2735 let path = http::uri::PathAndQuery::from_static(
2736 "/penumbra.view.v1.ViewService/IndexByAddress",
2737 );
2738 let mut req = request.into_request();
2739 req.extensions_mut()
2740 .insert(
2741 GrpcMethod::new("penumbra.view.v1.ViewService", "IndexByAddress"),
2742 );
2743 self.inner.unary(req, path, codec).await
2744 }
2745 pub async fn ephemeral_address(
2747 &mut self,
2748 request: impl tonic::IntoRequest<super::EphemeralAddressRequest>,
2749 ) -> std::result::Result<
2750 tonic::Response<super::EphemeralAddressResponse>,
2751 tonic::Status,
2752 > {
2753 self.inner
2754 .ready()
2755 .await
2756 .map_err(|e| {
2757 tonic::Status::unknown(
2758 format!("Service was not ready: {}", e.into()),
2759 )
2760 })?;
2761 let codec = tonic::codec::ProstCodec::default();
2762 let path = http::uri::PathAndQuery::from_static(
2763 "/penumbra.view.v1.ViewService/EphemeralAddress",
2764 );
2765 let mut req = request.into_request();
2766 req.extensions_mut()
2767 .insert(
2768 GrpcMethod::new("penumbra.view.v1.ViewService", "EphemeralAddress"),
2769 );
2770 self.inner.unary(req, path, codec).await
2771 }
2772 pub async fn balances(
2775 &mut self,
2776 request: impl tonic::IntoRequest<super::BalancesRequest>,
2777 ) -> std::result::Result<
2778 tonic::Response<tonic::codec::Streaming<super::BalancesResponse>>,
2779 tonic::Status,
2780 > {
2781 self.inner
2782 .ready()
2783 .await
2784 .map_err(|e| {
2785 tonic::Status::unknown(
2786 format!("Service was not ready: {}", e.into()),
2787 )
2788 })?;
2789 let codec = tonic::codec::ProstCodec::default();
2790 let path = http::uri::PathAndQuery::from_static(
2791 "/penumbra.view.v1.ViewService/Balances",
2792 );
2793 let mut req = request.into_request();
2794 req.extensions_mut()
2795 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "Balances"));
2796 self.inner.server_streaming(req, path, codec).await
2797 }
2798 pub async fn note_by_commitment(
2800 &mut self,
2801 request: impl tonic::IntoRequest<super::NoteByCommitmentRequest>,
2802 ) -> std::result::Result<
2803 tonic::Response<super::NoteByCommitmentResponse>,
2804 tonic::Status,
2805 > {
2806 self.inner
2807 .ready()
2808 .await
2809 .map_err(|e| {
2810 tonic::Status::unknown(
2811 format!("Service was not ready: {}", e.into()),
2812 )
2813 })?;
2814 let codec = tonic::codec::ProstCodec::default();
2815 let path = http::uri::PathAndQuery::from_static(
2816 "/penumbra.view.v1.ViewService/NoteByCommitment",
2817 );
2818 let mut req = request.into_request();
2819 req.extensions_mut()
2820 .insert(
2821 GrpcMethod::new("penumbra.view.v1.ViewService", "NoteByCommitment"),
2822 );
2823 self.inner.unary(req, path, codec).await
2824 }
2825 pub async fn swap_by_commitment(
2827 &mut self,
2828 request: impl tonic::IntoRequest<super::SwapByCommitmentRequest>,
2829 ) -> std::result::Result<
2830 tonic::Response<super::SwapByCommitmentResponse>,
2831 tonic::Status,
2832 > {
2833 self.inner
2834 .ready()
2835 .await
2836 .map_err(|e| {
2837 tonic::Status::unknown(
2838 format!("Service was not ready: {}", e.into()),
2839 )
2840 })?;
2841 let codec = tonic::codec::ProstCodec::default();
2842 let path = http::uri::PathAndQuery::from_static(
2843 "/penumbra.view.v1.ViewService/SwapByCommitment",
2844 );
2845 let mut req = request.into_request();
2846 req.extensions_mut()
2847 .insert(
2848 GrpcMethod::new("penumbra.view.v1.ViewService", "SwapByCommitment"),
2849 );
2850 self.inner.unary(req, path, codec).await
2851 }
2852 pub async fn unclaimed_swaps(
2854 &mut self,
2855 request: impl tonic::IntoRequest<super::UnclaimedSwapsRequest>,
2856 ) -> std::result::Result<
2857 tonic::Response<tonic::codec::Streaming<super::UnclaimedSwapsResponse>>,
2858 tonic::Status,
2859 > {
2860 self.inner
2861 .ready()
2862 .await
2863 .map_err(|e| {
2864 tonic::Status::unknown(
2865 format!("Service was not ready: {}", e.into()),
2866 )
2867 })?;
2868 let codec = tonic::codec::ProstCodec::default();
2869 let path = http::uri::PathAndQuery::from_static(
2870 "/penumbra.view.v1.ViewService/UnclaimedSwaps",
2871 );
2872 let mut req = request.into_request();
2873 req.extensions_mut()
2874 .insert(
2875 GrpcMethod::new("penumbra.view.v1.ViewService", "UnclaimedSwaps"),
2876 );
2877 self.inner.server_streaming(req, path, codec).await
2878 }
2879 pub async fn nullifier_status(
2881 &mut self,
2882 request: impl tonic::IntoRequest<super::NullifierStatusRequest>,
2883 ) -> std::result::Result<
2884 tonic::Response<super::NullifierStatusResponse>,
2885 tonic::Status,
2886 > {
2887 self.inner
2888 .ready()
2889 .await
2890 .map_err(|e| {
2891 tonic::Status::unknown(
2892 format!("Service was not ready: {}", e.into()),
2893 )
2894 })?;
2895 let codec = tonic::codec::ProstCodec::default();
2896 let path = http::uri::PathAndQuery::from_static(
2897 "/penumbra.view.v1.ViewService/NullifierStatus",
2898 );
2899 let mut req = request.into_request();
2900 req.extensions_mut()
2901 .insert(
2902 GrpcMethod::new("penumbra.view.v1.ViewService", "NullifierStatus"),
2903 );
2904 self.inner.unary(req, path, codec).await
2905 }
2906 pub async fn transaction_info_by_hash(
2908 &mut self,
2909 request: impl tonic::IntoRequest<super::TransactionInfoByHashRequest>,
2910 ) -> std::result::Result<
2911 tonic::Response<super::TransactionInfoByHashResponse>,
2912 tonic::Status,
2913 > {
2914 self.inner
2915 .ready()
2916 .await
2917 .map_err(|e| {
2918 tonic::Status::unknown(
2919 format!("Service was not ready: {}", e.into()),
2920 )
2921 })?;
2922 let codec = tonic::codec::ProstCodec::default();
2923 let path = http::uri::PathAndQuery::from_static(
2924 "/penumbra.view.v1.ViewService/TransactionInfoByHash",
2925 );
2926 let mut req = request.into_request();
2927 req.extensions_mut()
2928 .insert(
2929 GrpcMethod::new(
2930 "penumbra.view.v1.ViewService",
2931 "TransactionInfoByHash",
2932 ),
2933 );
2934 self.inner.unary(req, path, codec).await
2935 }
2936 pub async fn transaction_info(
2939 &mut self,
2940 request: impl tonic::IntoRequest<super::TransactionInfoRequest>,
2941 ) -> std::result::Result<
2942 tonic::Response<tonic::codec::Streaming<super::TransactionInfoResponse>>,
2943 tonic::Status,
2944 > {
2945 self.inner
2946 .ready()
2947 .await
2948 .map_err(|e| {
2949 tonic::Status::unknown(
2950 format!("Service was not ready: {}", e.into()),
2951 )
2952 })?;
2953 let codec = tonic::codec::ProstCodec::default();
2954 let path = http::uri::PathAndQuery::from_static(
2955 "/penumbra.view.v1.ViewService/TransactionInfo",
2956 );
2957 let mut req = request.into_request();
2958 req.extensions_mut()
2959 .insert(
2960 GrpcMethod::new("penumbra.view.v1.ViewService", "TransactionInfo"),
2961 );
2962 self.inner.server_streaming(req, path, codec).await
2963 }
2964 pub async fn owned_position_ids(
2966 &mut self,
2967 request: impl tonic::IntoRequest<super::OwnedPositionIdsRequest>,
2968 ) -> std::result::Result<
2969 tonic::Response<tonic::codec::Streaming<super::OwnedPositionIdsResponse>>,
2970 tonic::Status,
2971 > {
2972 self.inner
2973 .ready()
2974 .await
2975 .map_err(|e| {
2976 tonic::Status::unknown(
2977 format!("Service was not ready: {}", e.into()),
2978 )
2979 })?;
2980 let codec = tonic::codec::ProstCodec::default();
2981 let path = http::uri::PathAndQuery::from_static(
2982 "/penumbra.view.v1.ViewService/OwnedPositionIds",
2983 );
2984 let mut req = request.into_request();
2985 req.extensions_mut()
2986 .insert(
2987 GrpcMethod::new("penumbra.view.v1.ViewService", "OwnedPositionIds"),
2988 );
2989 self.inner.server_streaming(req, path, codec).await
2990 }
2991 pub async fn transaction_planner(
2993 &mut self,
2994 request: impl tonic::IntoRequest<super::TransactionPlannerRequest>,
2995 ) -> std::result::Result<
2996 tonic::Response<super::TransactionPlannerResponse>,
2997 tonic::Status,
2998 > {
2999 self.inner
3000 .ready()
3001 .await
3002 .map_err(|e| {
3003 tonic::Status::unknown(
3004 format!("Service was not ready: {}", e.into()),
3005 )
3006 })?;
3007 let codec = tonic::codec::ProstCodec::default();
3008 let path = http::uri::PathAndQuery::from_static(
3009 "/penumbra.view.v1.ViewService/TransactionPlanner",
3010 );
3011 let mut req = request.into_request();
3012 req.extensions_mut()
3013 .insert(
3014 GrpcMethod::new("penumbra.view.v1.ViewService", "TransactionPlanner"),
3015 );
3016 self.inner.unary(req, path, codec).await
3017 }
3018 pub async fn witness(
3025 &mut self,
3026 request: impl tonic::IntoRequest<super::WitnessRequest>,
3027 ) -> std::result::Result<
3028 tonic::Response<super::WitnessResponse>,
3029 tonic::Status,
3030 > {
3031 self.inner
3032 .ready()
3033 .await
3034 .map_err(|e| {
3035 tonic::Status::unknown(
3036 format!("Service was not ready: {}", e.into()),
3037 )
3038 })?;
3039 let codec = tonic::codec::ProstCodec::default();
3040 let path = http::uri::PathAndQuery::from_static(
3041 "/penumbra.view.v1.ViewService/Witness",
3042 );
3043 let mut req = request.into_request();
3044 req.extensions_mut()
3045 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "Witness"));
3046 self.inner.unary(req, path, codec).await
3047 }
3048 pub async fn witness_and_build(
3056 &mut self,
3057 request: impl tonic::IntoRequest<super::WitnessAndBuildRequest>,
3058 ) -> std::result::Result<
3059 tonic::Response<tonic::codec::Streaming<super::WitnessAndBuildResponse>>,
3060 tonic::Status,
3061 > {
3062 self.inner
3063 .ready()
3064 .await
3065 .map_err(|e| {
3066 tonic::Status::unknown(
3067 format!("Service was not ready: {}", e.into()),
3068 )
3069 })?;
3070 let codec = tonic::codec::ProstCodec::default();
3071 let path = http::uri::PathAndQuery::from_static(
3072 "/penumbra.view.v1.ViewService/WitnessAndBuild",
3073 );
3074 let mut req = request.into_request();
3075 req.extensions_mut()
3076 .insert(
3077 GrpcMethod::new("penumbra.view.v1.ViewService", "WitnessAndBuild"),
3078 );
3079 self.inner.server_streaming(req, path, codec).await
3080 }
3081 pub async fn authorize_and_build(
3093 &mut self,
3094 request: impl tonic::IntoRequest<super::AuthorizeAndBuildRequest>,
3095 ) -> std::result::Result<
3096 tonic::Response<tonic::codec::Streaming<super::AuthorizeAndBuildResponse>>,
3097 tonic::Status,
3098 > {
3099 self.inner
3100 .ready()
3101 .await
3102 .map_err(|e| {
3103 tonic::Status::unknown(
3104 format!("Service was not ready: {}", e.into()),
3105 )
3106 })?;
3107 let codec = tonic::codec::ProstCodec::default();
3108 let path = http::uri::PathAndQuery::from_static(
3109 "/penumbra.view.v1.ViewService/AuthorizeAndBuild",
3110 );
3111 let mut req = request.into_request();
3112 req.extensions_mut()
3113 .insert(
3114 GrpcMethod::new("penumbra.view.v1.ViewService", "AuthorizeAndBuild"),
3115 );
3116 self.inner.server_streaming(req, path, codec).await
3117 }
3118 pub async fn broadcast_transaction(
3122 &mut self,
3123 request: impl tonic::IntoRequest<super::BroadcastTransactionRequest>,
3124 ) -> std::result::Result<
3125 tonic::Response<
3126 tonic::codec::Streaming<super::BroadcastTransactionResponse>,
3127 >,
3128 tonic::Status,
3129 > {
3130 self.inner
3131 .ready()
3132 .await
3133 .map_err(|e| {
3134 tonic::Status::unknown(
3135 format!("Service was not ready: {}", e.into()),
3136 )
3137 })?;
3138 let codec = tonic::codec::ProstCodec::default();
3139 let path = http::uri::PathAndQuery::from_static(
3140 "/penumbra.view.v1.ViewService/BroadcastTransaction",
3141 );
3142 let mut req = request.into_request();
3143 req.extensions_mut()
3144 .insert(
3145 GrpcMethod::new(
3146 "penumbra.view.v1.ViewService",
3147 "BroadcastTransaction",
3148 ),
3149 );
3150 self.inner.server_streaming(req, path, codec).await
3151 }
3152 pub async fn delegations_by_address_index(
3157 &mut self,
3158 request: impl tonic::IntoRequest<super::DelegationsByAddressIndexRequest>,
3159 ) -> std::result::Result<
3160 tonic::Response<
3161 tonic::codec::Streaming<super::DelegationsByAddressIndexResponse>,
3162 >,
3163 tonic::Status,
3164 > {
3165 self.inner
3166 .ready()
3167 .await
3168 .map_err(|e| {
3169 tonic::Status::unknown(
3170 format!("Service was not ready: {}", e.into()),
3171 )
3172 })?;
3173 let codec = tonic::codec::ProstCodec::default();
3174 let path = http::uri::PathAndQuery::from_static(
3175 "/penumbra.view.v1.ViewService/DelegationsByAddressIndex",
3176 );
3177 let mut req = request.into_request();
3178 req.extensions_mut()
3179 .insert(
3180 GrpcMethod::new(
3181 "penumbra.view.v1.ViewService",
3182 "DelegationsByAddressIndex",
3183 ),
3184 );
3185 self.inner.server_streaming(req, path, codec).await
3186 }
3187 pub async fn unbonding_tokens_by_address_index(
3190 &mut self,
3191 request: impl tonic::IntoRequest<super::UnbondingTokensByAddressIndexRequest>,
3192 ) -> std::result::Result<
3193 tonic::Response<
3194 tonic::codec::Streaming<super::UnbondingTokensByAddressIndexResponse>,
3195 >,
3196 tonic::Status,
3197 > {
3198 self.inner
3199 .ready()
3200 .await
3201 .map_err(|e| {
3202 tonic::Status::unknown(
3203 format!("Service was not ready: {}", e.into()),
3204 )
3205 })?;
3206 let codec = tonic::codec::ProstCodec::default();
3207 let path = http::uri::PathAndQuery::from_static(
3208 "/penumbra.view.v1.ViewService/UnbondingTokensByAddressIndex",
3209 );
3210 let mut req = request.into_request();
3211 req.extensions_mut()
3212 .insert(
3213 GrpcMethod::new(
3214 "penumbra.view.v1.ViewService",
3215 "UnbondingTokensByAddressIndex",
3216 ),
3217 );
3218 self.inner.server_streaming(req, path, codec).await
3219 }
3220 pub async fn auctions(
3222 &mut self,
3223 request: impl tonic::IntoRequest<super::AuctionsRequest>,
3224 ) -> std::result::Result<
3225 tonic::Response<tonic::codec::Streaming<super::AuctionsResponse>>,
3226 tonic::Status,
3227 > {
3228 self.inner
3229 .ready()
3230 .await
3231 .map_err(|e| {
3232 tonic::Status::unknown(
3233 format!("Service was not ready: {}", e.into()),
3234 )
3235 })?;
3236 let codec = tonic::codec::ProstCodec::default();
3237 let path = http::uri::PathAndQuery::from_static(
3238 "/penumbra.view.v1.ViewService/Auctions",
3239 );
3240 let mut req = request.into_request();
3241 req.extensions_mut()
3242 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "Auctions"));
3243 self.inner.server_streaming(req, path, codec).await
3244 }
3245 pub async fn latest_swaps(
3247 &mut self,
3248 request: impl tonic::IntoRequest<super::LatestSwapsRequest>,
3249 ) -> std::result::Result<
3250 tonic::Response<tonic::codec::Streaming<super::LatestSwapsResponse>>,
3251 tonic::Status,
3252 > {
3253 self.inner
3254 .ready()
3255 .await
3256 .map_err(|e| {
3257 tonic::Status::unknown(
3258 format!("Service was not ready: {}", e.into()),
3259 )
3260 })?;
3261 let codec = tonic::codec::ProstCodec::default();
3262 let path = http::uri::PathAndQuery::from_static(
3263 "/penumbra.view.v1.ViewService/LatestSwaps",
3264 );
3265 let mut req = request.into_request();
3266 req.extensions_mut()
3267 .insert(GrpcMethod::new("penumbra.view.v1.ViewService", "LatestSwaps"));
3268 self.inner.server_streaming(req, path, codec).await
3269 }
3270 pub async fn tournament_votes(
3272 &mut self,
3273 request: impl tonic::IntoRequest<super::TournamentVotesRequest>,
3274 ) -> std::result::Result<
3275 tonic::Response<tonic::codec::Streaming<super::TournamentVotesResponse>>,
3276 tonic::Status,
3277 > {
3278 self.inner
3279 .ready()
3280 .await
3281 .map_err(|e| {
3282 tonic::Status::unknown(
3283 format!("Service was not ready: {}", e.into()),
3284 )
3285 })?;
3286 let codec = tonic::codec::ProstCodec::default();
3287 let path = http::uri::PathAndQuery::from_static(
3288 "/penumbra.view.v1.ViewService/TournamentVotes",
3289 );
3290 let mut req = request.into_request();
3291 req.extensions_mut()
3292 .insert(
3293 GrpcMethod::new("penumbra.view.v1.ViewService", "TournamentVotes"),
3294 );
3295 self.inner.server_streaming(req, path, codec).await
3296 }
3297 pub async fn lqt_voting_notes(
3299 &mut self,
3300 request: impl tonic::IntoRequest<super::LqtVotingNotesRequest>,
3301 ) -> std::result::Result<
3302 tonic::Response<tonic::codec::Streaming<super::LqtVotingNotesResponse>>,
3303 tonic::Status,
3304 > {
3305 self.inner
3306 .ready()
3307 .await
3308 .map_err(|e| {
3309 tonic::Status::unknown(
3310 format!("Service was not ready: {}", e.into()),
3311 )
3312 })?;
3313 let codec = tonic::codec::ProstCodec::default();
3314 let path = http::uri::PathAndQuery::from_static(
3315 "/penumbra.view.v1.ViewService/LqtVotingNotes",
3316 );
3317 let mut req = request.into_request();
3318 req.extensions_mut()
3319 .insert(
3320 GrpcMethod::new("penumbra.view.v1.ViewService", "LqtVotingNotes"),
3321 );
3322 self.inner.server_streaming(req, path, codec).await
3323 }
3324 pub async fn lp_position_bundle(
3326 &mut self,
3327 request: impl tonic::IntoRequest<super::LpPositionBundleRequest>,
3328 ) -> std::result::Result<
3329 tonic::Response<tonic::codec::Streaming<super::LpPositionBundleResponse>>,
3330 tonic::Status,
3331 > {
3332 self.inner
3333 .ready()
3334 .await
3335 .map_err(|e| {
3336 tonic::Status::unknown(
3337 format!("Service was not ready: {}", e.into()),
3338 )
3339 })?;
3340 let codec = tonic::codec::ProstCodec::default();
3341 let path = http::uri::PathAndQuery::from_static(
3342 "/penumbra.view.v1.ViewService/LpPositionBundle",
3343 );
3344 let mut req = request.into_request();
3345 req.extensions_mut()
3346 .insert(
3347 GrpcMethod::new("penumbra.view.v1.ViewService", "LpPositionBundle"),
3348 );
3349 self.inner.server_streaming(req, path, codec).await
3350 }
3351 pub async fn lp_strategy_catalog(
3353 &mut self,
3354 request: impl tonic::IntoRequest<super::LpStrategyCatalogRequest>,
3355 ) -> std::result::Result<
3356 tonic::Response<tonic::codec::Streaming<super::LpStrategyCatalogResponse>>,
3357 tonic::Status,
3358 > {
3359 self.inner
3360 .ready()
3361 .await
3362 .map_err(|e| {
3363 tonic::Status::unknown(
3364 format!("Service was not ready: {}", e.into()),
3365 )
3366 })?;
3367 let codec = tonic::codec::ProstCodec::default();
3368 let path = http::uri::PathAndQuery::from_static(
3369 "/penumbra.view.v1.ViewService/LpStrategyCatalog",
3370 );
3371 let mut req = request.into_request();
3372 req.extensions_mut()
3373 .insert(
3374 GrpcMethod::new("penumbra.view.v1.ViewService", "LpStrategyCatalog"),
3375 );
3376 self.inner.server_streaming(req, path, codec).await
3377 }
3378 }
3379}
3380#[cfg(feature = "rpc")]
3382pub mod view_service_server {
3383 #![allow(
3384 unused_variables,
3385 dead_code,
3386 missing_docs,
3387 clippy::wildcard_imports,
3388 clippy::let_unit_value,
3389 )]
3390 use tonic::codegen::*;
3391 #[async_trait]
3393 pub trait ViewService: std::marker::Send + std::marker::Sync + 'static {
3394 async fn status(
3396 &self,
3397 request: tonic::Request<super::StatusRequest>,
3398 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status>;
3399 type StatusStreamStream: tonic::codegen::tokio_stream::Stream<
3401 Item = std::result::Result<super::StatusStreamResponse, tonic::Status>,
3402 >
3403 + std::marker::Send
3404 + 'static;
3405 async fn status_stream(
3408 &self,
3409 request: tonic::Request<super::StatusStreamRequest>,
3410 ) -> std::result::Result<
3411 tonic::Response<Self::StatusStreamStream>,
3412 tonic::Status,
3413 >;
3414 type NotesStream: tonic::codegen::tokio_stream::Stream<
3416 Item = std::result::Result<super::NotesResponse, tonic::Status>,
3417 >
3418 + std::marker::Send
3419 + 'static;
3420 async fn notes(
3423 &self,
3424 request: tonic::Request<super::NotesRequest>,
3425 ) -> std::result::Result<tonic::Response<Self::NotesStream>, tonic::Status>;
3426 type NotesForVotingStream: tonic::codegen::tokio_stream::Stream<
3428 Item = std::result::Result<super::NotesForVotingResponse, tonic::Status>,
3429 >
3430 + std::marker::Send
3431 + 'static;
3432 async fn notes_for_voting(
3434 &self,
3435 request: tonic::Request<super::NotesForVotingRequest>,
3436 ) -> std::result::Result<
3437 tonic::Response<Self::NotesForVotingStream>,
3438 tonic::Status,
3439 >;
3440 type AssetsStream: tonic::codegen::tokio_stream::Stream<
3442 Item = std::result::Result<super::AssetsResponse, tonic::Status>,
3443 >
3444 + std::marker::Send
3445 + 'static;
3446 async fn assets(
3449 &self,
3450 request: tonic::Request<super::AssetsRequest>,
3451 ) -> std::result::Result<tonic::Response<Self::AssetsStream>, tonic::Status>;
3452 async fn asset_metadata_by_id(
3458 &self,
3459 request: tonic::Request<super::AssetMetadataByIdRequest>,
3460 ) -> std::result::Result<
3461 tonic::Response<super::AssetMetadataByIdResponse>,
3462 tonic::Status,
3463 >;
3464 async fn app_parameters(
3466 &self,
3467 request: tonic::Request<super::AppParametersRequest>,
3468 ) -> std::result::Result<
3469 tonic::Response<super::AppParametersResponse>,
3470 tonic::Status,
3471 >;
3472 async fn gas_prices(
3474 &self,
3475 request: tonic::Request<super::GasPricesRequest>,
3476 ) -> std::result::Result<
3477 tonic::Response<super::GasPricesResponse>,
3478 tonic::Status,
3479 >;
3480 async fn fmd_parameters(
3482 &self,
3483 request: tonic::Request<super::FmdParametersRequest>,
3484 ) -> std::result::Result<
3485 tonic::Response<super::FmdParametersResponse>,
3486 tonic::Status,
3487 >;
3488 async fn address_by_index(
3490 &self,
3491 request: tonic::Request<super::AddressByIndexRequest>,
3492 ) -> std::result::Result<
3493 tonic::Response<super::AddressByIndexResponse>,
3494 tonic::Status,
3495 >;
3496 async fn transparent_address(
3498 &self,
3499 request: tonic::Request<super::TransparentAddressRequest>,
3500 ) -> std::result::Result<
3501 tonic::Response<super::TransparentAddressResponse>,
3502 tonic::Status,
3503 >;
3504 async fn wallet_id(
3506 &self,
3507 request: tonic::Request<super::WalletIdRequest>,
3508 ) -> std::result::Result<
3509 tonic::Response<super::WalletIdResponse>,
3510 tonic::Status,
3511 >;
3512 async fn index_by_address(
3514 &self,
3515 request: tonic::Request<super::IndexByAddressRequest>,
3516 ) -> std::result::Result<
3517 tonic::Response<super::IndexByAddressResponse>,
3518 tonic::Status,
3519 >;
3520 async fn ephemeral_address(
3522 &self,
3523 request: tonic::Request<super::EphemeralAddressRequest>,
3524 ) -> std::result::Result<
3525 tonic::Response<super::EphemeralAddressResponse>,
3526 tonic::Status,
3527 >;
3528 type BalancesStream: tonic::codegen::tokio_stream::Stream<
3530 Item = std::result::Result<super::BalancesResponse, tonic::Status>,
3531 >
3532 + std::marker::Send
3533 + 'static;
3534 async fn balances(
3537 &self,
3538 request: tonic::Request<super::BalancesRequest>,
3539 ) -> std::result::Result<tonic::Response<Self::BalancesStream>, tonic::Status>;
3540 async fn note_by_commitment(
3542 &self,
3543 request: tonic::Request<super::NoteByCommitmentRequest>,
3544 ) -> std::result::Result<
3545 tonic::Response<super::NoteByCommitmentResponse>,
3546 tonic::Status,
3547 >;
3548 async fn swap_by_commitment(
3550 &self,
3551 request: tonic::Request<super::SwapByCommitmentRequest>,
3552 ) -> std::result::Result<
3553 tonic::Response<super::SwapByCommitmentResponse>,
3554 tonic::Status,
3555 >;
3556 type UnclaimedSwapsStream: tonic::codegen::tokio_stream::Stream<
3558 Item = std::result::Result<super::UnclaimedSwapsResponse, tonic::Status>,
3559 >
3560 + std::marker::Send
3561 + 'static;
3562 async fn unclaimed_swaps(
3564 &self,
3565 request: tonic::Request<super::UnclaimedSwapsRequest>,
3566 ) -> std::result::Result<
3567 tonic::Response<Self::UnclaimedSwapsStream>,
3568 tonic::Status,
3569 >;
3570 async fn nullifier_status(
3572 &self,
3573 request: tonic::Request<super::NullifierStatusRequest>,
3574 ) -> std::result::Result<
3575 tonic::Response<super::NullifierStatusResponse>,
3576 tonic::Status,
3577 >;
3578 async fn transaction_info_by_hash(
3580 &self,
3581 request: tonic::Request<super::TransactionInfoByHashRequest>,
3582 ) -> std::result::Result<
3583 tonic::Response<super::TransactionInfoByHashResponse>,
3584 tonic::Status,
3585 >;
3586 type TransactionInfoStream: tonic::codegen::tokio_stream::Stream<
3588 Item = std::result::Result<super::TransactionInfoResponse, tonic::Status>,
3589 >
3590 + std::marker::Send
3591 + 'static;
3592 async fn transaction_info(
3595 &self,
3596 request: tonic::Request<super::TransactionInfoRequest>,
3597 ) -> std::result::Result<
3598 tonic::Response<Self::TransactionInfoStream>,
3599 tonic::Status,
3600 >;
3601 type OwnedPositionIdsStream: tonic::codegen::tokio_stream::Stream<
3603 Item = std::result::Result<
3604 super::OwnedPositionIdsResponse,
3605 tonic::Status,
3606 >,
3607 >
3608 + std::marker::Send
3609 + 'static;
3610 async fn owned_position_ids(
3612 &self,
3613 request: tonic::Request<super::OwnedPositionIdsRequest>,
3614 ) -> std::result::Result<
3615 tonic::Response<Self::OwnedPositionIdsStream>,
3616 tonic::Status,
3617 >;
3618 async fn transaction_planner(
3620 &self,
3621 request: tonic::Request<super::TransactionPlannerRequest>,
3622 ) -> std::result::Result<
3623 tonic::Response<super::TransactionPlannerResponse>,
3624 tonic::Status,
3625 >;
3626 async fn witness(
3633 &self,
3634 request: tonic::Request<super::WitnessRequest>,
3635 ) -> std::result::Result<tonic::Response<super::WitnessResponse>, tonic::Status>;
3636 type WitnessAndBuildStream: tonic::codegen::tokio_stream::Stream<
3638 Item = std::result::Result<super::WitnessAndBuildResponse, tonic::Status>,
3639 >
3640 + std::marker::Send
3641 + 'static;
3642 async fn witness_and_build(
3650 &self,
3651 request: tonic::Request<super::WitnessAndBuildRequest>,
3652 ) -> std::result::Result<
3653 tonic::Response<Self::WitnessAndBuildStream>,
3654 tonic::Status,
3655 >;
3656 type AuthorizeAndBuildStream: tonic::codegen::tokio_stream::Stream<
3658 Item = std::result::Result<
3659 super::AuthorizeAndBuildResponse,
3660 tonic::Status,
3661 >,
3662 >
3663 + std::marker::Send
3664 + 'static;
3665 async fn authorize_and_build(
3677 &self,
3678 request: tonic::Request<super::AuthorizeAndBuildRequest>,
3679 ) -> std::result::Result<
3680 tonic::Response<Self::AuthorizeAndBuildStream>,
3681 tonic::Status,
3682 >;
3683 type BroadcastTransactionStream: tonic::codegen::tokio_stream::Stream<
3685 Item = std::result::Result<
3686 super::BroadcastTransactionResponse,
3687 tonic::Status,
3688 >,
3689 >
3690 + std::marker::Send
3691 + 'static;
3692 async fn broadcast_transaction(
3696 &self,
3697 request: tonic::Request<super::BroadcastTransactionRequest>,
3698 ) -> std::result::Result<
3699 tonic::Response<Self::BroadcastTransactionStream>,
3700 tonic::Status,
3701 >;
3702 type DelegationsByAddressIndexStream: tonic::codegen::tokio_stream::Stream<
3704 Item = std::result::Result<
3705 super::DelegationsByAddressIndexResponse,
3706 tonic::Status,
3707 >,
3708 >
3709 + std::marker::Send
3710 + 'static;
3711 async fn delegations_by_address_index(
3716 &self,
3717 request: tonic::Request<super::DelegationsByAddressIndexRequest>,
3718 ) -> std::result::Result<
3719 tonic::Response<Self::DelegationsByAddressIndexStream>,
3720 tonic::Status,
3721 >;
3722 type UnbondingTokensByAddressIndexStream: tonic::codegen::tokio_stream::Stream<
3724 Item = std::result::Result<
3725 super::UnbondingTokensByAddressIndexResponse,
3726 tonic::Status,
3727 >,
3728 >
3729 + std::marker::Send
3730 + 'static;
3731 async fn unbonding_tokens_by_address_index(
3734 &self,
3735 request: tonic::Request<super::UnbondingTokensByAddressIndexRequest>,
3736 ) -> std::result::Result<
3737 tonic::Response<Self::UnbondingTokensByAddressIndexStream>,
3738 tonic::Status,
3739 >;
3740 type AuctionsStream: tonic::codegen::tokio_stream::Stream<
3742 Item = std::result::Result<super::AuctionsResponse, tonic::Status>,
3743 >
3744 + std::marker::Send
3745 + 'static;
3746 async fn auctions(
3748 &self,
3749 request: tonic::Request<super::AuctionsRequest>,
3750 ) -> std::result::Result<tonic::Response<Self::AuctionsStream>, tonic::Status>;
3751 type LatestSwapsStream: tonic::codegen::tokio_stream::Stream<
3753 Item = std::result::Result<super::LatestSwapsResponse, tonic::Status>,
3754 >
3755 + std::marker::Send
3756 + 'static;
3757 async fn latest_swaps(
3759 &self,
3760 request: tonic::Request<super::LatestSwapsRequest>,
3761 ) -> std::result::Result<
3762 tonic::Response<Self::LatestSwapsStream>,
3763 tonic::Status,
3764 >;
3765 type TournamentVotesStream: tonic::codegen::tokio_stream::Stream<
3767 Item = std::result::Result<super::TournamentVotesResponse, tonic::Status>,
3768 >
3769 + std::marker::Send
3770 + 'static;
3771 async fn tournament_votes(
3773 &self,
3774 request: tonic::Request<super::TournamentVotesRequest>,
3775 ) -> std::result::Result<
3776 tonic::Response<Self::TournamentVotesStream>,
3777 tonic::Status,
3778 >;
3779 type LqtVotingNotesStream: tonic::codegen::tokio_stream::Stream<
3781 Item = std::result::Result<super::LqtVotingNotesResponse, tonic::Status>,
3782 >
3783 + std::marker::Send
3784 + 'static;
3785 async fn lqt_voting_notes(
3787 &self,
3788 request: tonic::Request<super::LqtVotingNotesRequest>,
3789 ) -> std::result::Result<
3790 tonic::Response<Self::LqtVotingNotesStream>,
3791 tonic::Status,
3792 >;
3793 type LpPositionBundleStream: tonic::codegen::tokio_stream::Stream<
3795 Item = std::result::Result<
3796 super::LpPositionBundleResponse,
3797 tonic::Status,
3798 >,
3799 >
3800 + std::marker::Send
3801 + 'static;
3802 async fn lp_position_bundle(
3804 &self,
3805 request: tonic::Request<super::LpPositionBundleRequest>,
3806 ) -> std::result::Result<
3807 tonic::Response<Self::LpPositionBundleStream>,
3808 tonic::Status,
3809 >;
3810 type LpStrategyCatalogStream: tonic::codegen::tokio_stream::Stream<
3812 Item = std::result::Result<
3813 super::LpStrategyCatalogResponse,
3814 tonic::Status,
3815 >,
3816 >
3817 + std::marker::Send
3818 + 'static;
3819 async fn lp_strategy_catalog(
3821 &self,
3822 request: tonic::Request<super::LpStrategyCatalogRequest>,
3823 ) -> std::result::Result<
3824 tonic::Response<Self::LpStrategyCatalogStream>,
3825 tonic::Status,
3826 >;
3827 }
3828 #[derive(Debug)]
3833 pub struct ViewServiceServer<T> {
3834 inner: Arc<T>,
3835 accept_compression_encodings: EnabledCompressionEncodings,
3836 send_compression_encodings: EnabledCompressionEncodings,
3837 max_decoding_message_size: Option<usize>,
3838 max_encoding_message_size: Option<usize>,
3839 }
3840 impl<T> ViewServiceServer<T> {
3841 pub fn new(inner: T) -> Self {
3842 Self::from_arc(Arc::new(inner))
3843 }
3844 pub fn from_arc(inner: Arc<T>) -> Self {
3845 Self {
3846 inner,
3847 accept_compression_encodings: Default::default(),
3848 send_compression_encodings: Default::default(),
3849 max_decoding_message_size: None,
3850 max_encoding_message_size: None,
3851 }
3852 }
3853 pub fn with_interceptor<F>(
3854 inner: T,
3855 interceptor: F,
3856 ) -> InterceptedService<Self, F>
3857 where
3858 F: tonic::service::Interceptor,
3859 {
3860 InterceptedService::new(Self::new(inner), interceptor)
3861 }
3862 #[must_use]
3864 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
3865 self.accept_compression_encodings.enable(encoding);
3866 self
3867 }
3868 #[must_use]
3870 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
3871 self.send_compression_encodings.enable(encoding);
3872 self
3873 }
3874 #[must_use]
3878 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
3879 self.max_decoding_message_size = Some(limit);
3880 self
3881 }
3882 #[must_use]
3886 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
3887 self.max_encoding_message_size = Some(limit);
3888 self
3889 }
3890 }
3891 impl<T, B> tonic::codegen::Service<http::Request<B>> for ViewServiceServer<T>
3892 where
3893 T: ViewService,
3894 B: Body + std::marker::Send + 'static,
3895 B::Error: Into<StdError> + std::marker::Send + 'static,
3896 {
3897 type Response = http::Response<tonic::body::BoxBody>;
3898 type Error = std::convert::Infallible;
3899 type Future = BoxFuture<Self::Response, Self::Error>;
3900 fn poll_ready(
3901 &mut self,
3902 _cx: &mut Context<'_>,
3903 ) -> Poll<std::result::Result<(), Self::Error>> {
3904 Poll::Ready(Ok(()))
3905 }
3906 fn call(&mut self, req: http::Request<B>) -> Self::Future {
3907 match req.uri().path() {
3908 "/penumbra.view.v1.ViewService/Status" => {
3909 #[allow(non_camel_case_types)]
3910 struct StatusSvc<T: ViewService>(pub Arc<T>);
3911 impl<
3912 T: ViewService,
3913 > tonic::server::UnaryService<super::StatusRequest>
3914 for StatusSvc<T> {
3915 type Response = super::StatusResponse;
3916 type Future = BoxFuture<
3917 tonic::Response<Self::Response>,
3918 tonic::Status,
3919 >;
3920 fn call(
3921 &mut self,
3922 request: tonic::Request<super::StatusRequest>,
3923 ) -> Self::Future {
3924 let inner = Arc::clone(&self.0);
3925 let fut = async move {
3926 <T as ViewService>::status(&inner, request).await
3927 };
3928 Box::pin(fut)
3929 }
3930 }
3931 let accept_compression_encodings = self.accept_compression_encodings;
3932 let send_compression_encodings = self.send_compression_encodings;
3933 let max_decoding_message_size = self.max_decoding_message_size;
3934 let max_encoding_message_size = self.max_encoding_message_size;
3935 let inner = self.inner.clone();
3936 let fut = async move {
3937 let method = StatusSvc(inner);
3938 let codec = tonic::codec::ProstCodec::default();
3939 let mut grpc = tonic::server::Grpc::new(codec)
3940 .apply_compression_config(
3941 accept_compression_encodings,
3942 send_compression_encodings,
3943 )
3944 .apply_max_message_size_config(
3945 max_decoding_message_size,
3946 max_encoding_message_size,
3947 );
3948 let res = grpc.unary(method, req).await;
3949 Ok(res)
3950 };
3951 Box::pin(fut)
3952 }
3953 "/penumbra.view.v1.ViewService/StatusStream" => {
3954 #[allow(non_camel_case_types)]
3955 struct StatusStreamSvc<T: ViewService>(pub Arc<T>);
3956 impl<
3957 T: ViewService,
3958 > tonic::server::ServerStreamingService<super::StatusStreamRequest>
3959 for StatusStreamSvc<T> {
3960 type Response = super::StatusStreamResponse;
3961 type ResponseStream = T::StatusStreamStream;
3962 type Future = BoxFuture<
3963 tonic::Response<Self::ResponseStream>,
3964 tonic::Status,
3965 >;
3966 fn call(
3967 &mut self,
3968 request: tonic::Request<super::StatusStreamRequest>,
3969 ) -> Self::Future {
3970 let inner = Arc::clone(&self.0);
3971 let fut = async move {
3972 <T as ViewService>::status_stream(&inner, request).await
3973 };
3974 Box::pin(fut)
3975 }
3976 }
3977 let accept_compression_encodings = self.accept_compression_encodings;
3978 let send_compression_encodings = self.send_compression_encodings;
3979 let max_decoding_message_size = self.max_decoding_message_size;
3980 let max_encoding_message_size = self.max_encoding_message_size;
3981 let inner = self.inner.clone();
3982 let fut = async move {
3983 let method = StatusStreamSvc(inner);
3984 let codec = tonic::codec::ProstCodec::default();
3985 let mut grpc = tonic::server::Grpc::new(codec)
3986 .apply_compression_config(
3987 accept_compression_encodings,
3988 send_compression_encodings,
3989 )
3990 .apply_max_message_size_config(
3991 max_decoding_message_size,
3992 max_encoding_message_size,
3993 );
3994 let res = grpc.server_streaming(method, req).await;
3995 Ok(res)
3996 };
3997 Box::pin(fut)
3998 }
3999 "/penumbra.view.v1.ViewService/Notes" => {
4000 #[allow(non_camel_case_types)]
4001 struct NotesSvc<T: ViewService>(pub Arc<T>);
4002 impl<
4003 T: ViewService,
4004 > tonic::server::ServerStreamingService<super::NotesRequest>
4005 for NotesSvc<T> {
4006 type Response = super::NotesResponse;
4007 type ResponseStream = T::NotesStream;
4008 type Future = BoxFuture<
4009 tonic::Response<Self::ResponseStream>,
4010 tonic::Status,
4011 >;
4012 fn call(
4013 &mut self,
4014 request: tonic::Request<super::NotesRequest>,
4015 ) -> Self::Future {
4016 let inner = Arc::clone(&self.0);
4017 let fut = async move {
4018 <T as ViewService>::notes(&inner, request).await
4019 };
4020 Box::pin(fut)
4021 }
4022 }
4023 let accept_compression_encodings = self.accept_compression_encodings;
4024 let send_compression_encodings = self.send_compression_encodings;
4025 let max_decoding_message_size = self.max_decoding_message_size;
4026 let max_encoding_message_size = self.max_encoding_message_size;
4027 let inner = self.inner.clone();
4028 let fut = async move {
4029 let method = NotesSvc(inner);
4030 let codec = tonic::codec::ProstCodec::default();
4031 let mut grpc = tonic::server::Grpc::new(codec)
4032 .apply_compression_config(
4033 accept_compression_encodings,
4034 send_compression_encodings,
4035 )
4036 .apply_max_message_size_config(
4037 max_decoding_message_size,
4038 max_encoding_message_size,
4039 );
4040 let res = grpc.server_streaming(method, req).await;
4041 Ok(res)
4042 };
4043 Box::pin(fut)
4044 }
4045 "/penumbra.view.v1.ViewService/NotesForVoting" => {
4046 #[allow(non_camel_case_types)]
4047 struct NotesForVotingSvc<T: ViewService>(pub Arc<T>);
4048 impl<
4049 T: ViewService,
4050 > tonic::server::ServerStreamingService<super::NotesForVotingRequest>
4051 for NotesForVotingSvc<T> {
4052 type Response = super::NotesForVotingResponse;
4053 type ResponseStream = T::NotesForVotingStream;
4054 type Future = BoxFuture<
4055 tonic::Response<Self::ResponseStream>,
4056 tonic::Status,
4057 >;
4058 fn call(
4059 &mut self,
4060 request: tonic::Request<super::NotesForVotingRequest>,
4061 ) -> Self::Future {
4062 let inner = Arc::clone(&self.0);
4063 let fut = async move {
4064 <T as ViewService>::notes_for_voting(&inner, request).await
4065 };
4066 Box::pin(fut)
4067 }
4068 }
4069 let accept_compression_encodings = self.accept_compression_encodings;
4070 let send_compression_encodings = self.send_compression_encodings;
4071 let max_decoding_message_size = self.max_decoding_message_size;
4072 let max_encoding_message_size = self.max_encoding_message_size;
4073 let inner = self.inner.clone();
4074 let fut = async move {
4075 let method = NotesForVotingSvc(inner);
4076 let codec = tonic::codec::ProstCodec::default();
4077 let mut grpc = tonic::server::Grpc::new(codec)
4078 .apply_compression_config(
4079 accept_compression_encodings,
4080 send_compression_encodings,
4081 )
4082 .apply_max_message_size_config(
4083 max_decoding_message_size,
4084 max_encoding_message_size,
4085 );
4086 let res = grpc.server_streaming(method, req).await;
4087 Ok(res)
4088 };
4089 Box::pin(fut)
4090 }
4091 "/penumbra.view.v1.ViewService/Assets" => {
4092 #[allow(non_camel_case_types)]
4093 struct AssetsSvc<T: ViewService>(pub Arc<T>);
4094 impl<
4095 T: ViewService,
4096 > tonic::server::ServerStreamingService<super::AssetsRequest>
4097 for AssetsSvc<T> {
4098 type Response = super::AssetsResponse;
4099 type ResponseStream = T::AssetsStream;
4100 type Future = BoxFuture<
4101 tonic::Response<Self::ResponseStream>,
4102 tonic::Status,
4103 >;
4104 fn call(
4105 &mut self,
4106 request: tonic::Request<super::AssetsRequest>,
4107 ) -> Self::Future {
4108 let inner = Arc::clone(&self.0);
4109 let fut = async move {
4110 <T as ViewService>::assets(&inner, request).await
4111 };
4112 Box::pin(fut)
4113 }
4114 }
4115 let accept_compression_encodings = self.accept_compression_encodings;
4116 let send_compression_encodings = self.send_compression_encodings;
4117 let max_decoding_message_size = self.max_decoding_message_size;
4118 let max_encoding_message_size = self.max_encoding_message_size;
4119 let inner = self.inner.clone();
4120 let fut = async move {
4121 let method = AssetsSvc(inner);
4122 let codec = tonic::codec::ProstCodec::default();
4123 let mut grpc = tonic::server::Grpc::new(codec)
4124 .apply_compression_config(
4125 accept_compression_encodings,
4126 send_compression_encodings,
4127 )
4128 .apply_max_message_size_config(
4129 max_decoding_message_size,
4130 max_encoding_message_size,
4131 );
4132 let res = grpc.server_streaming(method, req).await;
4133 Ok(res)
4134 };
4135 Box::pin(fut)
4136 }
4137 "/penumbra.view.v1.ViewService/AssetMetadataById" => {
4138 #[allow(non_camel_case_types)]
4139 struct AssetMetadataByIdSvc<T: ViewService>(pub Arc<T>);
4140 impl<
4141 T: ViewService,
4142 > tonic::server::UnaryService<super::AssetMetadataByIdRequest>
4143 for AssetMetadataByIdSvc<T> {
4144 type Response = super::AssetMetadataByIdResponse;
4145 type Future = BoxFuture<
4146 tonic::Response<Self::Response>,
4147 tonic::Status,
4148 >;
4149 fn call(
4150 &mut self,
4151 request: tonic::Request<super::AssetMetadataByIdRequest>,
4152 ) -> Self::Future {
4153 let inner = Arc::clone(&self.0);
4154 let fut = async move {
4155 <T as ViewService>::asset_metadata_by_id(&inner, request)
4156 .await
4157 };
4158 Box::pin(fut)
4159 }
4160 }
4161 let accept_compression_encodings = self.accept_compression_encodings;
4162 let send_compression_encodings = self.send_compression_encodings;
4163 let max_decoding_message_size = self.max_decoding_message_size;
4164 let max_encoding_message_size = self.max_encoding_message_size;
4165 let inner = self.inner.clone();
4166 let fut = async move {
4167 let method = AssetMetadataByIdSvc(inner);
4168 let codec = tonic::codec::ProstCodec::default();
4169 let mut grpc = tonic::server::Grpc::new(codec)
4170 .apply_compression_config(
4171 accept_compression_encodings,
4172 send_compression_encodings,
4173 )
4174 .apply_max_message_size_config(
4175 max_decoding_message_size,
4176 max_encoding_message_size,
4177 );
4178 let res = grpc.unary(method, req).await;
4179 Ok(res)
4180 };
4181 Box::pin(fut)
4182 }
4183 "/penumbra.view.v1.ViewService/AppParameters" => {
4184 #[allow(non_camel_case_types)]
4185 struct AppParametersSvc<T: ViewService>(pub Arc<T>);
4186 impl<
4187 T: ViewService,
4188 > tonic::server::UnaryService<super::AppParametersRequest>
4189 for AppParametersSvc<T> {
4190 type Response = super::AppParametersResponse;
4191 type Future = BoxFuture<
4192 tonic::Response<Self::Response>,
4193 tonic::Status,
4194 >;
4195 fn call(
4196 &mut self,
4197 request: tonic::Request<super::AppParametersRequest>,
4198 ) -> Self::Future {
4199 let inner = Arc::clone(&self.0);
4200 let fut = async move {
4201 <T as ViewService>::app_parameters(&inner, request).await
4202 };
4203 Box::pin(fut)
4204 }
4205 }
4206 let accept_compression_encodings = self.accept_compression_encodings;
4207 let send_compression_encodings = self.send_compression_encodings;
4208 let max_decoding_message_size = self.max_decoding_message_size;
4209 let max_encoding_message_size = self.max_encoding_message_size;
4210 let inner = self.inner.clone();
4211 let fut = async move {
4212 let method = AppParametersSvc(inner);
4213 let codec = tonic::codec::ProstCodec::default();
4214 let mut grpc = tonic::server::Grpc::new(codec)
4215 .apply_compression_config(
4216 accept_compression_encodings,
4217 send_compression_encodings,
4218 )
4219 .apply_max_message_size_config(
4220 max_decoding_message_size,
4221 max_encoding_message_size,
4222 );
4223 let res = grpc.unary(method, req).await;
4224 Ok(res)
4225 };
4226 Box::pin(fut)
4227 }
4228 "/penumbra.view.v1.ViewService/GasPrices" => {
4229 #[allow(non_camel_case_types)]
4230 struct GasPricesSvc<T: ViewService>(pub Arc<T>);
4231 impl<
4232 T: ViewService,
4233 > tonic::server::UnaryService<super::GasPricesRequest>
4234 for GasPricesSvc<T> {
4235 type Response = super::GasPricesResponse;
4236 type Future = BoxFuture<
4237 tonic::Response<Self::Response>,
4238 tonic::Status,
4239 >;
4240 fn call(
4241 &mut self,
4242 request: tonic::Request<super::GasPricesRequest>,
4243 ) -> Self::Future {
4244 let inner = Arc::clone(&self.0);
4245 let fut = async move {
4246 <T as ViewService>::gas_prices(&inner, request).await
4247 };
4248 Box::pin(fut)
4249 }
4250 }
4251 let accept_compression_encodings = self.accept_compression_encodings;
4252 let send_compression_encodings = self.send_compression_encodings;
4253 let max_decoding_message_size = self.max_decoding_message_size;
4254 let max_encoding_message_size = self.max_encoding_message_size;
4255 let inner = self.inner.clone();
4256 let fut = async move {
4257 let method = GasPricesSvc(inner);
4258 let codec = tonic::codec::ProstCodec::default();
4259 let mut grpc = tonic::server::Grpc::new(codec)
4260 .apply_compression_config(
4261 accept_compression_encodings,
4262 send_compression_encodings,
4263 )
4264 .apply_max_message_size_config(
4265 max_decoding_message_size,
4266 max_encoding_message_size,
4267 );
4268 let res = grpc.unary(method, req).await;
4269 Ok(res)
4270 };
4271 Box::pin(fut)
4272 }
4273 "/penumbra.view.v1.ViewService/FMDParameters" => {
4274 #[allow(non_camel_case_types)]
4275 struct FMDParametersSvc<T: ViewService>(pub Arc<T>);
4276 impl<
4277 T: ViewService,
4278 > tonic::server::UnaryService<super::FmdParametersRequest>
4279 for FMDParametersSvc<T> {
4280 type Response = super::FmdParametersResponse;
4281 type Future = BoxFuture<
4282 tonic::Response<Self::Response>,
4283 tonic::Status,
4284 >;
4285 fn call(
4286 &mut self,
4287 request: tonic::Request<super::FmdParametersRequest>,
4288 ) -> Self::Future {
4289 let inner = Arc::clone(&self.0);
4290 let fut = async move {
4291 <T as ViewService>::fmd_parameters(&inner, request).await
4292 };
4293 Box::pin(fut)
4294 }
4295 }
4296 let accept_compression_encodings = self.accept_compression_encodings;
4297 let send_compression_encodings = self.send_compression_encodings;
4298 let max_decoding_message_size = self.max_decoding_message_size;
4299 let max_encoding_message_size = self.max_encoding_message_size;
4300 let inner = self.inner.clone();
4301 let fut = async move {
4302 let method = FMDParametersSvc(inner);
4303 let codec = tonic::codec::ProstCodec::default();
4304 let mut grpc = tonic::server::Grpc::new(codec)
4305 .apply_compression_config(
4306 accept_compression_encodings,
4307 send_compression_encodings,
4308 )
4309 .apply_max_message_size_config(
4310 max_decoding_message_size,
4311 max_encoding_message_size,
4312 );
4313 let res = grpc.unary(method, req).await;
4314 Ok(res)
4315 };
4316 Box::pin(fut)
4317 }
4318 "/penumbra.view.v1.ViewService/AddressByIndex" => {
4319 #[allow(non_camel_case_types)]
4320 struct AddressByIndexSvc<T: ViewService>(pub Arc<T>);
4321 impl<
4322 T: ViewService,
4323 > tonic::server::UnaryService<super::AddressByIndexRequest>
4324 for AddressByIndexSvc<T> {
4325 type Response = super::AddressByIndexResponse;
4326 type Future = BoxFuture<
4327 tonic::Response<Self::Response>,
4328 tonic::Status,
4329 >;
4330 fn call(
4331 &mut self,
4332 request: tonic::Request<super::AddressByIndexRequest>,
4333 ) -> Self::Future {
4334 let inner = Arc::clone(&self.0);
4335 let fut = async move {
4336 <T as ViewService>::address_by_index(&inner, request).await
4337 };
4338 Box::pin(fut)
4339 }
4340 }
4341 let accept_compression_encodings = self.accept_compression_encodings;
4342 let send_compression_encodings = self.send_compression_encodings;
4343 let max_decoding_message_size = self.max_decoding_message_size;
4344 let max_encoding_message_size = self.max_encoding_message_size;
4345 let inner = self.inner.clone();
4346 let fut = async move {
4347 let method = AddressByIndexSvc(inner);
4348 let codec = tonic::codec::ProstCodec::default();
4349 let mut grpc = tonic::server::Grpc::new(codec)
4350 .apply_compression_config(
4351 accept_compression_encodings,
4352 send_compression_encodings,
4353 )
4354 .apply_max_message_size_config(
4355 max_decoding_message_size,
4356 max_encoding_message_size,
4357 );
4358 let res = grpc.unary(method, req).await;
4359 Ok(res)
4360 };
4361 Box::pin(fut)
4362 }
4363 "/penumbra.view.v1.ViewService/TransparentAddress" => {
4364 #[allow(non_camel_case_types)]
4365 struct TransparentAddressSvc<T: ViewService>(pub Arc<T>);
4366 impl<
4367 T: ViewService,
4368 > tonic::server::UnaryService<super::TransparentAddressRequest>
4369 for TransparentAddressSvc<T> {
4370 type Response = super::TransparentAddressResponse;
4371 type Future = BoxFuture<
4372 tonic::Response<Self::Response>,
4373 tonic::Status,
4374 >;
4375 fn call(
4376 &mut self,
4377 request: tonic::Request<super::TransparentAddressRequest>,
4378 ) -> Self::Future {
4379 let inner = Arc::clone(&self.0);
4380 let fut = async move {
4381 <T as ViewService>::transparent_address(&inner, request)
4382 .await
4383 };
4384 Box::pin(fut)
4385 }
4386 }
4387 let accept_compression_encodings = self.accept_compression_encodings;
4388 let send_compression_encodings = self.send_compression_encodings;
4389 let max_decoding_message_size = self.max_decoding_message_size;
4390 let max_encoding_message_size = self.max_encoding_message_size;
4391 let inner = self.inner.clone();
4392 let fut = async move {
4393 let method = TransparentAddressSvc(inner);
4394 let codec = tonic::codec::ProstCodec::default();
4395 let mut grpc = tonic::server::Grpc::new(codec)
4396 .apply_compression_config(
4397 accept_compression_encodings,
4398 send_compression_encodings,
4399 )
4400 .apply_max_message_size_config(
4401 max_decoding_message_size,
4402 max_encoding_message_size,
4403 );
4404 let res = grpc.unary(method, req).await;
4405 Ok(res)
4406 };
4407 Box::pin(fut)
4408 }
4409 "/penumbra.view.v1.ViewService/WalletId" => {
4410 #[allow(non_camel_case_types)]
4411 struct WalletIdSvc<T: ViewService>(pub Arc<T>);
4412 impl<
4413 T: ViewService,
4414 > tonic::server::UnaryService<super::WalletIdRequest>
4415 for WalletIdSvc<T> {
4416 type Response = super::WalletIdResponse;
4417 type Future = BoxFuture<
4418 tonic::Response<Self::Response>,
4419 tonic::Status,
4420 >;
4421 fn call(
4422 &mut self,
4423 request: tonic::Request<super::WalletIdRequest>,
4424 ) -> Self::Future {
4425 let inner = Arc::clone(&self.0);
4426 let fut = async move {
4427 <T as ViewService>::wallet_id(&inner, request).await
4428 };
4429 Box::pin(fut)
4430 }
4431 }
4432 let accept_compression_encodings = self.accept_compression_encodings;
4433 let send_compression_encodings = self.send_compression_encodings;
4434 let max_decoding_message_size = self.max_decoding_message_size;
4435 let max_encoding_message_size = self.max_encoding_message_size;
4436 let inner = self.inner.clone();
4437 let fut = async move {
4438 let method = WalletIdSvc(inner);
4439 let codec = tonic::codec::ProstCodec::default();
4440 let mut grpc = tonic::server::Grpc::new(codec)
4441 .apply_compression_config(
4442 accept_compression_encodings,
4443 send_compression_encodings,
4444 )
4445 .apply_max_message_size_config(
4446 max_decoding_message_size,
4447 max_encoding_message_size,
4448 );
4449 let res = grpc.unary(method, req).await;
4450 Ok(res)
4451 };
4452 Box::pin(fut)
4453 }
4454 "/penumbra.view.v1.ViewService/IndexByAddress" => {
4455 #[allow(non_camel_case_types)]
4456 struct IndexByAddressSvc<T: ViewService>(pub Arc<T>);
4457 impl<
4458 T: ViewService,
4459 > tonic::server::UnaryService<super::IndexByAddressRequest>
4460 for IndexByAddressSvc<T> {
4461 type Response = super::IndexByAddressResponse;
4462 type Future = BoxFuture<
4463 tonic::Response<Self::Response>,
4464 tonic::Status,
4465 >;
4466 fn call(
4467 &mut self,
4468 request: tonic::Request<super::IndexByAddressRequest>,
4469 ) -> Self::Future {
4470 let inner = Arc::clone(&self.0);
4471 let fut = async move {
4472 <T as ViewService>::index_by_address(&inner, request).await
4473 };
4474 Box::pin(fut)
4475 }
4476 }
4477 let accept_compression_encodings = self.accept_compression_encodings;
4478 let send_compression_encodings = self.send_compression_encodings;
4479 let max_decoding_message_size = self.max_decoding_message_size;
4480 let max_encoding_message_size = self.max_encoding_message_size;
4481 let inner = self.inner.clone();
4482 let fut = async move {
4483 let method = IndexByAddressSvc(inner);
4484 let codec = tonic::codec::ProstCodec::default();
4485 let mut grpc = tonic::server::Grpc::new(codec)
4486 .apply_compression_config(
4487 accept_compression_encodings,
4488 send_compression_encodings,
4489 )
4490 .apply_max_message_size_config(
4491 max_decoding_message_size,
4492 max_encoding_message_size,
4493 );
4494 let res = grpc.unary(method, req).await;
4495 Ok(res)
4496 };
4497 Box::pin(fut)
4498 }
4499 "/penumbra.view.v1.ViewService/EphemeralAddress" => {
4500 #[allow(non_camel_case_types)]
4501 struct EphemeralAddressSvc<T: ViewService>(pub Arc<T>);
4502 impl<
4503 T: ViewService,
4504 > tonic::server::UnaryService<super::EphemeralAddressRequest>
4505 for EphemeralAddressSvc<T> {
4506 type Response = super::EphemeralAddressResponse;
4507 type Future = BoxFuture<
4508 tonic::Response<Self::Response>,
4509 tonic::Status,
4510 >;
4511 fn call(
4512 &mut self,
4513 request: tonic::Request<super::EphemeralAddressRequest>,
4514 ) -> Self::Future {
4515 let inner = Arc::clone(&self.0);
4516 let fut = async move {
4517 <T as ViewService>::ephemeral_address(&inner, request).await
4518 };
4519 Box::pin(fut)
4520 }
4521 }
4522 let accept_compression_encodings = self.accept_compression_encodings;
4523 let send_compression_encodings = self.send_compression_encodings;
4524 let max_decoding_message_size = self.max_decoding_message_size;
4525 let max_encoding_message_size = self.max_encoding_message_size;
4526 let inner = self.inner.clone();
4527 let fut = async move {
4528 let method = EphemeralAddressSvc(inner);
4529 let codec = tonic::codec::ProstCodec::default();
4530 let mut grpc = tonic::server::Grpc::new(codec)
4531 .apply_compression_config(
4532 accept_compression_encodings,
4533 send_compression_encodings,
4534 )
4535 .apply_max_message_size_config(
4536 max_decoding_message_size,
4537 max_encoding_message_size,
4538 );
4539 let res = grpc.unary(method, req).await;
4540 Ok(res)
4541 };
4542 Box::pin(fut)
4543 }
4544 "/penumbra.view.v1.ViewService/Balances" => {
4545 #[allow(non_camel_case_types)]
4546 struct BalancesSvc<T: ViewService>(pub Arc<T>);
4547 impl<
4548 T: ViewService,
4549 > tonic::server::ServerStreamingService<super::BalancesRequest>
4550 for BalancesSvc<T> {
4551 type Response = super::BalancesResponse;
4552 type ResponseStream = T::BalancesStream;
4553 type Future = BoxFuture<
4554 tonic::Response<Self::ResponseStream>,
4555 tonic::Status,
4556 >;
4557 fn call(
4558 &mut self,
4559 request: tonic::Request<super::BalancesRequest>,
4560 ) -> Self::Future {
4561 let inner = Arc::clone(&self.0);
4562 let fut = async move {
4563 <T as ViewService>::balances(&inner, request).await
4564 };
4565 Box::pin(fut)
4566 }
4567 }
4568 let accept_compression_encodings = self.accept_compression_encodings;
4569 let send_compression_encodings = self.send_compression_encodings;
4570 let max_decoding_message_size = self.max_decoding_message_size;
4571 let max_encoding_message_size = self.max_encoding_message_size;
4572 let inner = self.inner.clone();
4573 let fut = async move {
4574 let method = BalancesSvc(inner);
4575 let codec = tonic::codec::ProstCodec::default();
4576 let mut grpc = tonic::server::Grpc::new(codec)
4577 .apply_compression_config(
4578 accept_compression_encodings,
4579 send_compression_encodings,
4580 )
4581 .apply_max_message_size_config(
4582 max_decoding_message_size,
4583 max_encoding_message_size,
4584 );
4585 let res = grpc.server_streaming(method, req).await;
4586 Ok(res)
4587 };
4588 Box::pin(fut)
4589 }
4590 "/penumbra.view.v1.ViewService/NoteByCommitment" => {
4591 #[allow(non_camel_case_types)]
4592 struct NoteByCommitmentSvc<T: ViewService>(pub Arc<T>);
4593 impl<
4594 T: ViewService,
4595 > tonic::server::UnaryService<super::NoteByCommitmentRequest>
4596 for NoteByCommitmentSvc<T> {
4597 type Response = super::NoteByCommitmentResponse;
4598 type Future = BoxFuture<
4599 tonic::Response<Self::Response>,
4600 tonic::Status,
4601 >;
4602 fn call(
4603 &mut self,
4604 request: tonic::Request<super::NoteByCommitmentRequest>,
4605 ) -> Self::Future {
4606 let inner = Arc::clone(&self.0);
4607 let fut = async move {
4608 <T as ViewService>::note_by_commitment(&inner, request)
4609 .await
4610 };
4611 Box::pin(fut)
4612 }
4613 }
4614 let accept_compression_encodings = self.accept_compression_encodings;
4615 let send_compression_encodings = self.send_compression_encodings;
4616 let max_decoding_message_size = self.max_decoding_message_size;
4617 let max_encoding_message_size = self.max_encoding_message_size;
4618 let inner = self.inner.clone();
4619 let fut = async move {
4620 let method = NoteByCommitmentSvc(inner);
4621 let codec = tonic::codec::ProstCodec::default();
4622 let mut grpc = tonic::server::Grpc::new(codec)
4623 .apply_compression_config(
4624 accept_compression_encodings,
4625 send_compression_encodings,
4626 )
4627 .apply_max_message_size_config(
4628 max_decoding_message_size,
4629 max_encoding_message_size,
4630 );
4631 let res = grpc.unary(method, req).await;
4632 Ok(res)
4633 };
4634 Box::pin(fut)
4635 }
4636 "/penumbra.view.v1.ViewService/SwapByCommitment" => {
4637 #[allow(non_camel_case_types)]
4638 struct SwapByCommitmentSvc<T: ViewService>(pub Arc<T>);
4639 impl<
4640 T: ViewService,
4641 > tonic::server::UnaryService<super::SwapByCommitmentRequest>
4642 for SwapByCommitmentSvc<T> {
4643 type Response = super::SwapByCommitmentResponse;
4644 type Future = BoxFuture<
4645 tonic::Response<Self::Response>,
4646 tonic::Status,
4647 >;
4648 fn call(
4649 &mut self,
4650 request: tonic::Request<super::SwapByCommitmentRequest>,
4651 ) -> Self::Future {
4652 let inner = Arc::clone(&self.0);
4653 let fut = async move {
4654 <T as ViewService>::swap_by_commitment(&inner, request)
4655 .await
4656 };
4657 Box::pin(fut)
4658 }
4659 }
4660 let accept_compression_encodings = self.accept_compression_encodings;
4661 let send_compression_encodings = self.send_compression_encodings;
4662 let max_decoding_message_size = self.max_decoding_message_size;
4663 let max_encoding_message_size = self.max_encoding_message_size;
4664 let inner = self.inner.clone();
4665 let fut = async move {
4666 let method = SwapByCommitmentSvc(inner);
4667 let codec = tonic::codec::ProstCodec::default();
4668 let mut grpc = tonic::server::Grpc::new(codec)
4669 .apply_compression_config(
4670 accept_compression_encodings,
4671 send_compression_encodings,
4672 )
4673 .apply_max_message_size_config(
4674 max_decoding_message_size,
4675 max_encoding_message_size,
4676 );
4677 let res = grpc.unary(method, req).await;
4678 Ok(res)
4679 };
4680 Box::pin(fut)
4681 }
4682 "/penumbra.view.v1.ViewService/UnclaimedSwaps" => {
4683 #[allow(non_camel_case_types)]
4684 struct UnclaimedSwapsSvc<T: ViewService>(pub Arc<T>);
4685 impl<
4686 T: ViewService,
4687 > tonic::server::ServerStreamingService<super::UnclaimedSwapsRequest>
4688 for UnclaimedSwapsSvc<T> {
4689 type Response = super::UnclaimedSwapsResponse;
4690 type ResponseStream = T::UnclaimedSwapsStream;
4691 type Future = BoxFuture<
4692 tonic::Response<Self::ResponseStream>,
4693 tonic::Status,
4694 >;
4695 fn call(
4696 &mut self,
4697 request: tonic::Request<super::UnclaimedSwapsRequest>,
4698 ) -> Self::Future {
4699 let inner = Arc::clone(&self.0);
4700 let fut = async move {
4701 <T as ViewService>::unclaimed_swaps(&inner, request).await
4702 };
4703 Box::pin(fut)
4704 }
4705 }
4706 let accept_compression_encodings = self.accept_compression_encodings;
4707 let send_compression_encodings = self.send_compression_encodings;
4708 let max_decoding_message_size = self.max_decoding_message_size;
4709 let max_encoding_message_size = self.max_encoding_message_size;
4710 let inner = self.inner.clone();
4711 let fut = async move {
4712 let method = UnclaimedSwapsSvc(inner);
4713 let codec = tonic::codec::ProstCodec::default();
4714 let mut grpc = tonic::server::Grpc::new(codec)
4715 .apply_compression_config(
4716 accept_compression_encodings,
4717 send_compression_encodings,
4718 )
4719 .apply_max_message_size_config(
4720 max_decoding_message_size,
4721 max_encoding_message_size,
4722 );
4723 let res = grpc.server_streaming(method, req).await;
4724 Ok(res)
4725 };
4726 Box::pin(fut)
4727 }
4728 "/penumbra.view.v1.ViewService/NullifierStatus" => {
4729 #[allow(non_camel_case_types)]
4730 struct NullifierStatusSvc<T: ViewService>(pub Arc<T>);
4731 impl<
4732 T: ViewService,
4733 > tonic::server::UnaryService<super::NullifierStatusRequest>
4734 for NullifierStatusSvc<T> {
4735 type Response = super::NullifierStatusResponse;
4736 type Future = BoxFuture<
4737 tonic::Response<Self::Response>,
4738 tonic::Status,
4739 >;
4740 fn call(
4741 &mut self,
4742 request: tonic::Request<super::NullifierStatusRequest>,
4743 ) -> Self::Future {
4744 let inner = Arc::clone(&self.0);
4745 let fut = async move {
4746 <T as ViewService>::nullifier_status(&inner, request).await
4747 };
4748 Box::pin(fut)
4749 }
4750 }
4751 let accept_compression_encodings = self.accept_compression_encodings;
4752 let send_compression_encodings = self.send_compression_encodings;
4753 let max_decoding_message_size = self.max_decoding_message_size;
4754 let max_encoding_message_size = self.max_encoding_message_size;
4755 let inner = self.inner.clone();
4756 let fut = async move {
4757 let method = NullifierStatusSvc(inner);
4758 let codec = tonic::codec::ProstCodec::default();
4759 let mut grpc = tonic::server::Grpc::new(codec)
4760 .apply_compression_config(
4761 accept_compression_encodings,
4762 send_compression_encodings,
4763 )
4764 .apply_max_message_size_config(
4765 max_decoding_message_size,
4766 max_encoding_message_size,
4767 );
4768 let res = grpc.unary(method, req).await;
4769 Ok(res)
4770 };
4771 Box::pin(fut)
4772 }
4773 "/penumbra.view.v1.ViewService/TransactionInfoByHash" => {
4774 #[allow(non_camel_case_types)]
4775 struct TransactionInfoByHashSvc<T: ViewService>(pub Arc<T>);
4776 impl<
4777 T: ViewService,
4778 > tonic::server::UnaryService<super::TransactionInfoByHashRequest>
4779 for TransactionInfoByHashSvc<T> {
4780 type Response = super::TransactionInfoByHashResponse;
4781 type Future = BoxFuture<
4782 tonic::Response<Self::Response>,
4783 tonic::Status,
4784 >;
4785 fn call(
4786 &mut self,
4787 request: tonic::Request<super::TransactionInfoByHashRequest>,
4788 ) -> Self::Future {
4789 let inner = Arc::clone(&self.0);
4790 let fut = async move {
4791 <T as ViewService>::transaction_info_by_hash(
4792 &inner,
4793 request,
4794 )
4795 .await
4796 };
4797 Box::pin(fut)
4798 }
4799 }
4800 let accept_compression_encodings = self.accept_compression_encodings;
4801 let send_compression_encodings = self.send_compression_encodings;
4802 let max_decoding_message_size = self.max_decoding_message_size;
4803 let max_encoding_message_size = self.max_encoding_message_size;
4804 let inner = self.inner.clone();
4805 let fut = async move {
4806 let method = TransactionInfoByHashSvc(inner);
4807 let codec = tonic::codec::ProstCodec::default();
4808 let mut grpc = tonic::server::Grpc::new(codec)
4809 .apply_compression_config(
4810 accept_compression_encodings,
4811 send_compression_encodings,
4812 )
4813 .apply_max_message_size_config(
4814 max_decoding_message_size,
4815 max_encoding_message_size,
4816 );
4817 let res = grpc.unary(method, req).await;
4818 Ok(res)
4819 };
4820 Box::pin(fut)
4821 }
4822 "/penumbra.view.v1.ViewService/TransactionInfo" => {
4823 #[allow(non_camel_case_types)]
4824 struct TransactionInfoSvc<T: ViewService>(pub Arc<T>);
4825 impl<
4826 T: ViewService,
4827 > tonic::server::ServerStreamingService<
4828 super::TransactionInfoRequest,
4829 > for TransactionInfoSvc<T> {
4830 type Response = super::TransactionInfoResponse;
4831 type ResponseStream = T::TransactionInfoStream;
4832 type Future = BoxFuture<
4833 tonic::Response<Self::ResponseStream>,
4834 tonic::Status,
4835 >;
4836 fn call(
4837 &mut self,
4838 request: tonic::Request<super::TransactionInfoRequest>,
4839 ) -> Self::Future {
4840 let inner = Arc::clone(&self.0);
4841 let fut = async move {
4842 <T as ViewService>::transaction_info(&inner, request).await
4843 };
4844 Box::pin(fut)
4845 }
4846 }
4847 let accept_compression_encodings = self.accept_compression_encodings;
4848 let send_compression_encodings = self.send_compression_encodings;
4849 let max_decoding_message_size = self.max_decoding_message_size;
4850 let max_encoding_message_size = self.max_encoding_message_size;
4851 let inner = self.inner.clone();
4852 let fut = async move {
4853 let method = TransactionInfoSvc(inner);
4854 let codec = tonic::codec::ProstCodec::default();
4855 let mut grpc = tonic::server::Grpc::new(codec)
4856 .apply_compression_config(
4857 accept_compression_encodings,
4858 send_compression_encodings,
4859 )
4860 .apply_max_message_size_config(
4861 max_decoding_message_size,
4862 max_encoding_message_size,
4863 );
4864 let res = grpc.server_streaming(method, req).await;
4865 Ok(res)
4866 };
4867 Box::pin(fut)
4868 }
4869 "/penumbra.view.v1.ViewService/OwnedPositionIds" => {
4870 #[allow(non_camel_case_types)]
4871 struct OwnedPositionIdsSvc<T: ViewService>(pub Arc<T>);
4872 impl<
4873 T: ViewService,
4874 > tonic::server::ServerStreamingService<
4875 super::OwnedPositionIdsRequest,
4876 > for OwnedPositionIdsSvc<T> {
4877 type Response = super::OwnedPositionIdsResponse;
4878 type ResponseStream = T::OwnedPositionIdsStream;
4879 type Future = BoxFuture<
4880 tonic::Response<Self::ResponseStream>,
4881 tonic::Status,
4882 >;
4883 fn call(
4884 &mut self,
4885 request: tonic::Request<super::OwnedPositionIdsRequest>,
4886 ) -> Self::Future {
4887 let inner = Arc::clone(&self.0);
4888 let fut = async move {
4889 <T as ViewService>::owned_position_ids(&inner, request)
4890 .await
4891 };
4892 Box::pin(fut)
4893 }
4894 }
4895 let accept_compression_encodings = self.accept_compression_encodings;
4896 let send_compression_encodings = self.send_compression_encodings;
4897 let max_decoding_message_size = self.max_decoding_message_size;
4898 let max_encoding_message_size = self.max_encoding_message_size;
4899 let inner = self.inner.clone();
4900 let fut = async move {
4901 let method = OwnedPositionIdsSvc(inner);
4902 let codec = tonic::codec::ProstCodec::default();
4903 let mut grpc = tonic::server::Grpc::new(codec)
4904 .apply_compression_config(
4905 accept_compression_encodings,
4906 send_compression_encodings,
4907 )
4908 .apply_max_message_size_config(
4909 max_decoding_message_size,
4910 max_encoding_message_size,
4911 );
4912 let res = grpc.server_streaming(method, req).await;
4913 Ok(res)
4914 };
4915 Box::pin(fut)
4916 }
4917 "/penumbra.view.v1.ViewService/TransactionPlanner" => {
4918 #[allow(non_camel_case_types)]
4919 struct TransactionPlannerSvc<T: ViewService>(pub Arc<T>);
4920 impl<
4921 T: ViewService,
4922 > tonic::server::UnaryService<super::TransactionPlannerRequest>
4923 for TransactionPlannerSvc<T> {
4924 type Response = super::TransactionPlannerResponse;
4925 type Future = BoxFuture<
4926 tonic::Response<Self::Response>,
4927 tonic::Status,
4928 >;
4929 fn call(
4930 &mut self,
4931 request: tonic::Request<super::TransactionPlannerRequest>,
4932 ) -> Self::Future {
4933 let inner = Arc::clone(&self.0);
4934 let fut = async move {
4935 <T as ViewService>::transaction_planner(&inner, request)
4936 .await
4937 };
4938 Box::pin(fut)
4939 }
4940 }
4941 let accept_compression_encodings = self.accept_compression_encodings;
4942 let send_compression_encodings = self.send_compression_encodings;
4943 let max_decoding_message_size = self.max_decoding_message_size;
4944 let max_encoding_message_size = self.max_encoding_message_size;
4945 let inner = self.inner.clone();
4946 let fut = async move {
4947 let method = TransactionPlannerSvc(inner);
4948 let codec = tonic::codec::ProstCodec::default();
4949 let mut grpc = tonic::server::Grpc::new(codec)
4950 .apply_compression_config(
4951 accept_compression_encodings,
4952 send_compression_encodings,
4953 )
4954 .apply_max_message_size_config(
4955 max_decoding_message_size,
4956 max_encoding_message_size,
4957 );
4958 let res = grpc.unary(method, req).await;
4959 Ok(res)
4960 };
4961 Box::pin(fut)
4962 }
4963 "/penumbra.view.v1.ViewService/Witness" => {
4964 #[allow(non_camel_case_types)]
4965 struct WitnessSvc<T: ViewService>(pub Arc<T>);
4966 impl<
4967 T: ViewService,
4968 > tonic::server::UnaryService<super::WitnessRequest>
4969 for WitnessSvc<T> {
4970 type Response = super::WitnessResponse;
4971 type Future = BoxFuture<
4972 tonic::Response<Self::Response>,
4973 tonic::Status,
4974 >;
4975 fn call(
4976 &mut self,
4977 request: tonic::Request<super::WitnessRequest>,
4978 ) -> Self::Future {
4979 let inner = Arc::clone(&self.0);
4980 let fut = async move {
4981 <T as ViewService>::witness(&inner, request).await
4982 };
4983 Box::pin(fut)
4984 }
4985 }
4986 let accept_compression_encodings = self.accept_compression_encodings;
4987 let send_compression_encodings = self.send_compression_encodings;
4988 let max_decoding_message_size = self.max_decoding_message_size;
4989 let max_encoding_message_size = self.max_encoding_message_size;
4990 let inner = self.inner.clone();
4991 let fut = async move {
4992 let method = WitnessSvc(inner);
4993 let codec = tonic::codec::ProstCodec::default();
4994 let mut grpc = tonic::server::Grpc::new(codec)
4995 .apply_compression_config(
4996 accept_compression_encodings,
4997 send_compression_encodings,
4998 )
4999 .apply_max_message_size_config(
5000 max_decoding_message_size,
5001 max_encoding_message_size,
5002 );
5003 let res = grpc.unary(method, req).await;
5004 Ok(res)
5005 };
5006 Box::pin(fut)
5007 }
5008 "/penumbra.view.v1.ViewService/WitnessAndBuild" => {
5009 #[allow(non_camel_case_types)]
5010 struct WitnessAndBuildSvc<T: ViewService>(pub Arc<T>);
5011 impl<
5012 T: ViewService,
5013 > tonic::server::ServerStreamingService<
5014 super::WitnessAndBuildRequest,
5015 > for WitnessAndBuildSvc<T> {
5016 type Response = super::WitnessAndBuildResponse;
5017 type ResponseStream = T::WitnessAndBuildStream;
5018 type Future = BoxFuture<
5019 tonic::Response<Self::ResponseStream>,
5020 tonic::Status,
5021 >;
5022 fn call(
5023 &mut self,
5024 request: tonic::Request<super::WitnessAndBuildRequest>,
5025 ) -> Self::Future {
5026 let inner = Arc::clone(&self.0);
5027 let fut = async move {
5028 <T as ViewService>::witness_and_build(&inner, request).await
5029 };
5030 Box::pin(fut)
5031 }
5032 }
5033 let accept_compression_encodings = self.accept_compression_encodings;
5034 let send_compression_encodings = self.send_compression_encodings;
5035 let max_decoding_message_size = self.max_decoding_message_size;
5036 let max_encoding_message_size = self.max_encoding_message_size;
5037 let inner = self.inner.clone();
5038 let fut = async move {
5039 let method = WitnessAndBuildSvc(inner);
5040 let codec = tonic::codec::ProstCodec::default();
5041 let mut grpc = tonic::server::Grpc::new(codec)
5042 .apply_compression_config(
5043 accept_compression_encodings,
5044 send_compression_encodings,
5045 )
5046 .apply_max_message_size_config(
5047 max_decoding_message_size,
5048 max_encoding_message_size,
5049 );
5050 let res = grpc.server_streaming(method, req).await;
5051 Ok(res)
5052 };
5053 Box::pin(fut)
5054 }
5055 "/penumbra.view.v1.ViewService/AuthorizeAndBuild" => {
5056 #[allow(non_camel_case_types)]
5057 struct AuthorizeAndBuildSvc<T: ViewService>(pub Arc<T>);
5058 impl<
5059 T: ViewService,
5060 > tonic::server::ServerStreamingService<
5061 super::AuthorizeAndBuildRequest,
5062 > for AuthorizeAndBuildSvc<T> {
5063 type Response = super::AuthorizeAndBuildResponse;
5064 type ResponseStream = T::AuthorizeAndBuildStream;
5065 type Future = BoxFuture<
5066 tonic::Response<Self::ResponseStream>,
5067 tonic::Status,
5068 >;
5069 fn call(
5070 &mut self,
5071 request: tonic::Request<super::AuthorizeAndBuildRequest>,
5072 ) -> Self::Future {
5073 let inner = Arc::clone(&self.0);
5074 let fut = async move {
5075 <T as ViewService>::authorize_and_build(&inner, request)
5076 .await
5077 };
5078 Box::pin(fut)
5079 }
5080 }
5081 let accept_compression_encodings = self.accept_compression_encodings;
5082 let send_compression_encodings = self.send_compression_encodings;
5083 let max_decoding_message_size = self.max_decoding_message_size;
5084 let max_encoding_message_size = self.max_encoding_message_size;
5085 let inner = self.inner.clone();
5086 let fut = async move {
5087 let method = AuthorizeAndBuildSvc(inner);
5088 let codec = tonic::codec::ProstCodec::default();
5089 let mut grpc = tonic::server::Grpc::new(codec)
5090 .apply_compression_config(
5091 accept_compression_encodings,
5092 send_compression_encodings,
5093 )
5094 .apply_max_message_size_config(
5095 max_decoding_message_size,
5096 max_encoding_message_size,
5097 );
5098 let res = grpc.server_streaming(method, req).await;
5099 Ok(res)
5100 };
5101 Box::pin(fut)
5102 }
5103 "/penumbra.view.v1.ViewService/BroadcastTransaction" => {
5104 #[allow(non_camel_case_types)]
5105 struct BroadcastTransactionSvc<T: ViewService>(pub Arc<T>);
5106 impl<
5107 T: ViewService,
5108 > tonic::server::ServerStreamingService<
5109 super::BroadcastTransactionRequest,
5110 > for BroadcastTransactionSvc<T> {
5111 type Response = super::BroadcastTransactionResponse;
5112 type ResponseStream = T::BroadcastTransactionStream;
5113 type Future = BoxFuture<
5114 tonic::Response<Self::ResponseStream>,
5115 tonic::Status,
5116 >;
5117 fn call(
5118 &mut self,
5119 request: tonic::Request<super::BroadcastTransactionRequest>,
5120 ) -> Self::Future {
5121 let inner = Arc::clone(&self.0);
5122 let fut = async move {
5123 <T as ViewService>::broadcast_transaction(&inner, request)
5124 .await
5125 };
5126 Box::pin(fut)
5127 }
5128 }
5129 let accept_compression_encodings = self.accept_compression_encodings;
5130 let send_compression_encodings = self.send_compression_encodings;
5131 let max_decoding_message_size = self.max_decoding_message_size;
5132 let max_encoding_message_size = self.max_encoding_message_size;
5133 let inner = self.inner.clone();
5134 let fut = async move {
5135 let method = BroadcastTransactionSvc(inner);
5136 let codec = tonic::codec::ProstCodec::default();
5137 let mut grpc = tonic::server::Grpc::new(codec)
5138 .apply_compression_config(
5139 accept_compression_encodings,
5140 send_compression_encodings,
5141 )
5142 .apply_max_message_size_config(
5143 max_decoding_message_size,
5144 max_encoding_message_size,
5145 );
5146 let res = grpc.server_streaming(method, req).await;
5147 Ok(res)
5148 };
5149 Box::pin(fut)
5150 }
5151 "/penumbra.view.v1.ViewService/DelegationsByAddressIndex" => {
5152 #[allow(non_camel_case_types)]
5153 struct DelegationsByAddressIndexSvc<T: ViewService>(pub Arc<T>);
5154 impl<
5155 T: ViewService,
5156 > tonic::server::ServerStreamingService<
5157 super::DelegationsByAddressIndexRequest,
5158 > for DelegationsByAddressIndexSvc<T> {
5159 type Response = super::DelegationsByAddressIndexResponse;
5160 type ResponseStream = T::DelegationsByAddressIndexStream;
5161 type Future = BoxFuture<
5162 tonic::Response<Self::ResponseStream>,
5163 tonic::Status,
5164 >;
5165 fn call(
5166 &mut self,
5167 request: tonic::Request<
5168 super::DelegationsByAddressIndexRequest,
5169 >,
5170 ) -> Self::Future {
5171 let inner = Arc::clone(&self.0);
5172 let fut = async move {
5173 <T as ViewService>::delegations_by_address_index(
5174 &inner,
5175 request,
5176 )
5177 .await
5178 };
5179 Box::pin(fut)
5180 }
5181 }
5182 let accept_compression_encodings = self.accept_compression_encodings;
5183 let send_compression_encodings = self.send_compression_encodings;
5184 let max_decoding_message_size = self.max_decoding_message_size;
5185 let max_encoding_message_size = self.max_encoding_message_size;
5186 let inner = self.inner.clone();
5187 let fut = async move {
5188 let method = DelegationsByAddressIndexSvc(inner);
5189 let codec = tonic::codec::ProstCodec::default();
5190 let mut grpc = tonic::server::Grpc::new(codec)
5191 .apply_compression_config(
5192 accept_compression_encodings,
5193 send_compression_encodings,
5194 )
5195 .apply_max_message_size_config(
5196 max_decoding_message_size,
5197 max_encoding_message_size,
5198 );
5199 let res = grpc.server_streaming(method, req).await;
5200 Ok(res)
5201 };
5202 Box::pin(fut)
5203 }
5204 "/penumbra.view.v1.ViewService/UnbondingTokensByAddressIndex" => {
5205 #[allow(non_camel_case_types)]
5206 struct UnbondingTokensByAddressIndexSvc<T: ViewService>(pub Arc<T>);
5207 impl<
5208 T: ViewService,
5209 > tonic::server::ServerStreamingService<
5210 super::UnbondingTokensByAddressIndexRequest,
5211 > for UnbondingTokensByAddressIndexSvc<T> {
5212 type Response = super::UnbondingTokensByAddressIndexResponse;
5213 type ResponseStream = T::UnbondingTokensByAddressIndexStream;
5214 type Future = BoxFuture<
5215 tonic::Response<Self::ResponseStream>,
5216 tonic::Status,
5217 >;
5218 fn call(
5219 &mut self,
5220 request: tonic::Request<
5221 super::UnbondingTokensByAddressIndexRequest,
5222 >,
5223 ) -> Self::Future {
5224 let inner = Arc::clone(&self.0);
5225 let fut = async move {
5226 <T as ViewService>::unbonding_tokens_by_address_index(
5227 &inner,
5228 request,
5229 )
5230 .await
5231 };
5232 Box::pin(fut)
5233 }
5234 }
5235 let accept_compression_encodings = self.accept_compression_encodings;
5236 let send_compression_encodings = self.send_compression_encodings;
5237 let max_decoding_message_size = self.max_decoding_message_size;
5238 let max_encoding_message_size = self.max_encoding_message_size;
5239 let inner = self.inner.clone();
5240 let fut = async move {
5241 let method = UnbondingTokensByAddressIndexSvc(inner);
5242 let codec = tonic::codec::ProstCodec::default();
5243 let mut grpc = tonic::server::Grpc::new(codec)
5244 .apply_compression_config(
5245 accept_compression_encodings,
5246 send_compression_encodings,
5247 )
5248 .apply_max_message_size_config(
5249 max_decoding_message_size,
5250 max_encoding_message_size,
5251 );
5252 let res = grpc.server_streaming(method, req).await;
5253 Ok(res)
5254 };
5255 Box::pin(fut)
5256 }
5257 "/penumbra.view.v1.ViewService/Auctions" => {
5258 #[allow(non_camel_case_types)]
5259 struct AuctionsSvc<T: ViewService>(pub Arc<T>);
5260 impl<
5261 T: ViewService,
5262 > tonic::server::ServerStreamingService<super::AuctionsRequest>
5263 for AuctionsSvc<T> {
5264 type Response = super::AuctionsResponse;
5265 type ResponseStream = T::AuctionsStream;
5266 type Future = BoxFuture<
5267 tonic::Response<Self::ResponseStream>,
5268 tonic::Status,
5269 >;
5270 fn call(
5271 &mut self,
5272 request: tonic::Request<super::AuctionsRequest>,
5273 ) -> Self::Future {
5274 let inner = Arc::clone(&self.0);
5275 let fut = async move {
5276 <T as ViewService>::auctions(&inner, request).await
5277 };
5278 Box::pin(fut)
5279 }
5280 }
5281 let accept_compression_encodings = self.accept_compression_encodings;
5282 let send_compression_encodings = self.send_compression_encodings;
5283 let max_decoding_message_size = self.max_decoding_message_size;
5284 let max_encoding_message_size = self.max_encoding_message_size;
5285 let inner = self.inner.clone();
5286 let fut = async move {
5287 let method = AuctionsSvc(inner);
5288 let codec = tonic::codec::ProstCodec::default();
5289 let mut grpc = tonic::server::Grpc::new(codec)
5290 .apply_compression_config(
5291 accept_compression_encodings,
5292 send_compression_encodings,
5293 )
5294 .apply_max_message_size_config(
5295 max_decoding_message_size,
5296 max_encoding_message_size,
5297 );
5298 let res = grpc.server_streaming(method, req).await;
5299 Ok(res)
5300 };
5301 Box::pin(fut)
5302 }
5303 "/penumbra.view.v1.ViewService/LatestSwaps" => {
5304 #[allow(non_camel_case_types)]
5305 struct LatestSwapsSvc<T: ViewService>(pub Arc<T>);
5306 impl<
5307 T: ViewService,
5308 > tonic::server::ServerStreamingService<super::LatestSwapsRequest>
5309 for LatestSwapsSvc<T> {
5310 type Response = super::LatestSwapsResponse;
5311 type ResponseStream = T::LatestSwapsStream;
5312 type Future = BoxFuture<
5313 tonic::Response<Self::ResponseStream>,
5314 tonic::Status,
5315 >;
5316 fn call(
5317 &mut self,
5318 request: tonic::Request<super::LatestSwapsRequest>,
5319 ) -> Self::Future {
5320 let inner = Arc::clone(&self.0);
5321 let fut = async move {
5322 <T as ViewService>::latest_swaps(&inner, request).await
5323 };
5324 Box::pin(fut)
5325 }
5326 }
5327 let accept_compression_encodings = self.accept_compression_encodings;
5328 let send_compression_encodings = self.send_compression_encodings;
5329 let max_decoding_message_size = self.max_decoding_message_size;
5330 let max_encoding_message_size = self.max_encoding_message_size;
5331 let inner = self.inner.clone();
5332 let fut = async move {
5333 let method = LatestSwapsSvc(inner);
5334 let codec = tonic::codec::ProstCodec::default();
5335 let mut grpc = tonic::server::Grpc::new(codec)
5336 .apply_compression_config(
5337 accept_compression_encodings,
5338 send_compression_encodings,
5339 )
5340 .apply_max_message_size_config(
5341 max_decoding_message_size,
5342 max_encoding_message_size,
5343 );
5344 let res = grpc.server_streaming(method, req).await;
5345 Ok(res)
5346 };
5347 Box::pin(fut)
5348 }
5349 "/penumbra.view.v1.ViewService/TournamentVotes" => {
5350 #[allow(non_camel_case_types)]
5351 struct TournamentVotesSvc<T: ViewService>(pub Arc<T>);
5352 impl<
5353 T: ViewService,
5354 > tonic::server::ServerStreamingService<
5355 super::TournamentVotesRequest,
5356 > for TournamentVotesSvc<T> {
5357 type Response = super::TournamentVotesResponse;
5358 type ResponseStream = T::TournamentVotesStream;
5359 type Future = BoxFuture<
5360 tonic::Response<Self::ResponseStream>,
5361 tonic::Status,
5362 >;
5363 fn call(
5364 &mut self,
5365 request: tonic::Request<super::TournamentVotesRequest>,
5366 ) -> Self::Future {
5367 let inner = Arc::clone(&self.0);
5368 let fut = async move {
5369 <T as ViewService>::tournament_votes(&inner, request).await
5370 };
5371 Box::pin(fut)
5372 }
5373 }
5374 let accept_compression_encodings = self.accept_compression_encodings;
5375 let send_compression_encodings = self.send_compression_encodings;
5376 let max_decoding_message_size = self.max_decoding_message_size;
5377 let max_encoding_message_size = self.max_encoding_message_size;
5378 let inner = self.inner.clone();
5379 let fut = async move {
5380 let method = TournamentVotesSvc(inner);
5381 let codec = tonic::codec::ProstCodec::default();
5382 let mut grpc = tonic::server::Grpc::new(codec)
5383 .apply_compression_config(
5384 accept_compression_encodings,
5385 send_compression_encodings,
5386 )
5387 .apply_max_message_size_config(
5388 max_decoding_message_size,
5389 max_encoding_message_size,
5390 );
5391 let res = grpc.server_streaming(method, req).await;
5392 Ok(res)
5393 };
5394 Box::pin(fut)
5395 }
5396 "/penumbra.view.v1.ViewService/LqtVotingNotes" => {
5397 #[allow(non_camel_case_types)]
5398 struct LqtVotingNotesSvc<T: ViewService>(pub Arc<T>);
5399 impl<
5400 T: ViewService,
5401 > tonic::server::ServerStreamingService<super::LqtVotingNotesRequest>
5402 for LqtVotingNotesSvc<T> {
5403 type Response = super::LqtVotingNotesResponse;
5404 type ResponseStream = T::LqtVotingNotesStream;
5405 type Future = BoxFuture<
5406 tonic::Response<Self::ResponseStream>,
5407 tonic::Status,
5408 >;
5409 fn call(
5410 &mut self,
5411 request: tonic::Request<super::LqtVotingNotesRequest>,
5412 ) -> Self::Future {
5413 let inner = Arc::clone(&self.0);
5414 let fut = async move {
5415 <T as ViewService>::lqt_voting_notes(&inner, request).await
5416 };
5417 Box::pin(fut)
5418 }
5419 }
5420 let accept_compression_encodings = self.accept_compression_encodings;
5421 let send_compression_encodings = self.send_compression_encodings;
5422 let max_decoding_message_size = self.max_decoding_message_size;
5423 let max_encoding_message_size = self.max_encoding_message_size;
5424 let inner = self.inner.clone();
5425 let fut = async move {
5426 let method = LqtVotingNotesSvc(inner);
5427 let codec = tonic::codec::ProstCodec::default();
5428 let mut grpc = tonic::server::Grpc::new(codec)
5429 .apply_compression_config(
5430 accept_compression_encodings,
5431 send_compression_encodings,
5432 )
5433 .apply_max_message_size_config(
5434 max_decoding_message_size,
5435 max_encoding_message_size,
5436 );
5437 let res = grpc.server_streaming(method, req).await;
5438 Ok(res)
5439 };
5440 Box::pin(fut)
5441 }
5442 "/penumbra.view.v1.ViewService/LpPositionBundle" => {
5443 #[allow(non_camel_case_types)]
5444 struct LpPositionBundleSvc<T: ViewService>(pub Arc<T>);
5445 impl<
5446 T: ViewService,
5447 > tonic::server::ServerStreamingService<
5448 super::LpPositionBundleRequest,
5449 > for LpPositionBundleSvc<T> {
5450 type Response = super::LpPositionBundleResponse;
5451 type ResponseStream = T::LpPositionBundleStream;
5452 type Future = BoxFuture<
5453 tonic::Response<Self::ResponseStream>,
5454 tonic::Status,
5455 >;
5456 fn call(
5457 &mut self,
5458 request: tonic::Request<super::LpPositionBundleRequest>,
5459 ) -> Self::Future {
5460 let inner = Arc::clone(&self.0);
5461 let fut = async move {
5462 <T as ViewService>::lp_position_bundle(&inner, request)
5463 .await
5464 };
5465 Box::pin(fut)
5466 }
5467 }
5468 let accept_compression_encodings = self.accept_compression_encodings;
5469 let send_compression_encodings = self.send_compression_encodings;
5470 let max_decoding_message_size = self.max_decoding_message_size;
5471 let max_encoding_message_size = self.max_encoding_message_size;
5472 let inner = self.inner.clone();
5473 let fut = async move {
5474 let method = LpPositionBundleSvc(inner);
5475 let codec = tonic::codec::ProstCodec::default();
5476 let mut grpc = tonic::server::Grpc::new(codec)
5477 .apply_compression_config(
5478 accept_compression_encodings,
5479 send_compression_encodings,
5480 )
5481 .apply_max_message_size_config(
5482 max_decoding_message_size,
5483 max_encoding_message_size,
5484 );
5485 let res = grpc.server_streaming(method, req).await;
5486 Ok(res)
5487 };
5488 Box::pin(fut)
5489 }
5490 "/penumbra.view.v1.ViewService/LpStrategyCatalog" => {
5491 #[allow(non_camel_case_types)]
5492 struct LpStrategyCatalogSvc<T: ViewService>(pub Arc<T>);
5493 impl<
5494 T: ViewService,
5495 > tonic::server::ServerStreamingService<
5496 super::LpStrategyCatalogRequest,
5497 > for LpStrategyCatalogSvc<T> {
5498 type Response = super::LpStrategyCatalogResponse;
5499 type ResponseStream = T::LpStrategyCatalogStream;
5500 type Future = BoxFuture<
5501 tonic::Response<Self::ResponseStream>,
5502 tonic::Status,
5503 >;
5504 fn call(
5505 &mut self,
5506 request: tonic::Request<super::LpStrategyCatalogRequest>,
5507 ) -> Self::Future {
5508 let inner = Arc::clone(&self.0);
5509 let fut = async move {
5510 <T as ViewService>::lp_strategy_catalog(&inner, request)
5511 .await
5512 };
5513 Box::pin(fut)
5514 }
5515 }
5516 let accept_compression_encodings = self.accept_compression_encodings;
5517 let send_compression_encodings = self.send_compression_encodings;
5518 let max_decoding_message_size = self.max_decoding_message_size;
5519 let max_encoding_message_size = self.max_encoding_message_size;
5520 let inner = self.inner.clone();
5521 let fut = async move {
5522 let method = LpStrategyCatalogSvc(inner);
5523 let codec = tonic::codec::ProstCodec::default();
5524 let mut grpc = tonic::server::Grpc::new(codec)
5525 .apply_compression_config(
5526 accept_compression_encodings,
5527 send_compression_encodings,
5528 )
5529 .apply_max_message_size_config(
5530 max_decoding_message_size,
5531 max_encoding_message_size,
5532 );
5533 let res = grpc.server_streaming(method, req).await;
5534 Ok(res)
5535 };
5536 Box::pin(fut)
5537 }
5538 _ => {
5539 Box::pin(async move {
5540 let mut response = http::Response::new(empty_body());
5541 let headers = response.headers_mut();
5542 headers
5543 .insert(
5544 tonic::Status::GRPC_STATUS,
5545 (tonic::Code::Unimplemented as i32).into(),
5546 );
5547 headers
5548 .insert(
5549 http::header::CONTENT_TYPE,
5550 tonic::metadata::GRPC_CONTENT_TYPE,
5551 );
5552 Ok(response)
5553 })
5554 }
5555 }
5556 }
5557 }
5558 impl<T> Clone for ViewServiceServer<T> {
5559 fn clone(&self) -> Self {
5560 let inner = self.inner.clone();
5561 Self {
5562 inner,
5563 accept_compression_encodings: self.accept_compression_encodings,
5564 send_compression_encodings: self.send_compression_encodings,
5565 max_decoding_message_size: self.max_decoding_message_size,
5566 max_encoding_message_size: self.max_encoding_message_size,
5567 }
5568 }
5569 }
5570 pub const SERVICE_NAME: &str = "penumbra.view.v1.ViewService";
5572 impl<T> tonic::server::NamedService for ViewServiceServer<T> {
5573 const NAME: &'static str = SERVICE_NAME;
5574 }
5575}