penumbra_sdk_proto/gen/
penumbra.view.v1.rs

1// This file is @generated by prost-build.
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct LqtVotingNotesRequest {
4    /// The epoch index to check for nullifier usage.
5    #[prost(uint64, tag = "1")]
6    pub epoch_index: u64,
7    /// If present, filter balances to only include the account specified by the `AddressIndex`.
8    #[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    /// The delegation note that can be used to vote with in current epoch, only if `already_voted` is false.
26    #[prost(message, optional, tag = "1")]
27    pub note_record: ::core::option::Option<SpendableNoteRecord>,
28    /// Flag indicating whether each note was already used for voting in the current epoch.
29    #[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/// Note: implementations must not accept messages with both `epoch_index`
43/// and `block_height` set. This is a convenience API, to allow consumers
44/// to defer epoch tracking to a view service.
45#[derive(Clone, PartialEq, ::prost::Message)]
46pub struct TournamentVotesRequest {
47    /// Retrieves votes for the specified epoch.
48    #[prost(uint64, tag = "1")]
49    pub epoch_index: u64,
50    /// Retrieves votes as of the specified block height.
51    #[prost(uint64, tag = "2")]
52    pub block_height: u64,
53    /// If present, filter votes to only include the account specified by the `AddressIndex`.
54    #[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    /// A list of votes cast for the incentivized asset.
72    #[prost(message, repeated, tag = "1")]
73    pub votes: ::prost::alloc::vec::Vec<tournament_votes_response::Vote>,
74}
75/// Nested message and enum types in `TournamentVotesResponse`.
76pub mod tournament_votes_response {
77    #[derive(Clone, PartialEq, ::prost::Message)]
78    pub struct Vote {
79        /// The incentivized asset receiving this vote.
80        #[prost(message, optional, tag = "1")]
81        pub incentivized_asset: ::core::option::Option<
82            super::super::super::core::asset::v1::AssetId,
83        >,
84        /// The amount of voting power that this specific vote contributed.
85        #[prost(message, optional, tag = "2")]
86        pub vote_power: ::core::option::Option<
87            super::super::super::core::num::v1::Amount,
88        >,
89        /// The amount of rewards issued for votes on this asset.
90        #[prost(message, optional, tag = "3")]
91        pub reward: ::core::option::Option<super::super::super::core::asset::v1::Value>,
92        /// The transaction ID for the vote.
93        #[prost(message, optional, tag = "4")]
94        pub transaction: ::core::option::Option<
95            super::super::super::core::txhash::v1::TransactionId,
96        >,
97        /// Epoch index the vote occured in.
98        #[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/// There's only one transparent address per wallet, so this request has no parameters;
123/// the message exists to satisfy forward-compatibility properties.
124#[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    /// The raw (binary) transparent address
139    #[prost(message, optional, tag = "1")]
140    pub address: ::core::option::Option<super::super::core::keys::v1::Address>,
141    /// The t-address encoding of the transparent address
142    #[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/// Filters in an `AuctionsRequest` will be combined using `AND` logic -- that
156/// is, the more filters you add, the fewer responses you're likely to get.
157#[derive(Clone, PartialEq, ::prost::Message)]
158pub struct AuctionsRequest {
159    /// If present, filter balances to only include the account specified by the `AddressIndex`.
160    #[prost(message, optional, tag = "1")]
161    pub account_filter: ::core::option::Option<
162        super::super::core::keys::v1::AddressIndex,
163    >,
164    /// If present, include inactive auctions as well as active ones.
165    #[prost(bool, tag = "2")]
166    pub include_inactive: bool,
167    /// If set, query a fullnode for the current state of the auctions.
168    #[prost(bool, tag = "3")]
169    pub query_latest_state: bool,
170    /// If present, filter to only include auctions whose IDs are in this array.
171    #[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    /// The state of the returned auction.
193    ///
194    /// Only present when `query_latest_state` was provided.
195    #[prost(message, optional, tag = "2")]
196    pub auction: ::core::option::Option<::pbjson_types::Any>,
197    /// The state of any DEX positions relevant to the returned auction.
198    ///
199    /// Only present when `query_latest_state` was provided.
200    /// Could be empty, depending on the auction state.
201    #[prost(message, repeated, tag = "3")]
202    pub positions: ::prost::alloc::vec::Vec<
203        super::super::core::component::dex::v1::Position,
204    >,
205    /// The note recording the auction NFT.
206    #[prost(message, optional, tag = "4")]
207    pub note_record: ::core::option::Option<SpendableNoteRecord>,
208    /// The sequence number of the auction state *as known to the local view
209    /// service*. Note that the local view service may lag behind the fullnode. For
210    /// example, if the chain hits an auction's `end_height`, but the user hasn't
211    /// yet exchanged their sequence-0 (opened) auction NFT for a sequence-1
212    /// (closed) auction NFT, the local view service will have a sequence number of
213    /// 0.
214    ///
215    /// Dutch auctions move from:
216    /// 0 (opened) => 1 (closed) => n (withdrawn)
217    #[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    /// The transaction plan to authorize and build.
233    #[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}
253/// Nested message and enum types in `AuthorizeAndBuildResponse`.
254pub mod authorize_and_build_response {
255    /// Signals that building is in progress.
256    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
257    pub struct BuildProgress {
258        /// An approximate progress of the build, from 0 to 1.
259        #[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    /// Signals that the transaction is complete.
273    #[derive(Clone, PartialEq, ::prost::Message)]
274    pub struct Complete {
275        /// The finished transaction.
276        #[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    /// The transaction to broadcast.
312    #[prost(message, optional, tag = "1")]
313    pub transaction: ::core::option::Option<
314        super::super::core::transaction::v1::Transaction,
315    >,
316    /// If true, wait for the view service to detect the transaction during sync.
317    #[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}
335/// Nested message and enum types in `BroadcastTransactionResponse`.
336pub mod broadcast_transaction_response {
337    /// Signals that the transaction was broadcast successfully (but has not been confirmed).
338    #[derive(Clone, PartialEq, ::prost::Message)]
339    pub struct BroadcastSuccess {
340        /// The hash of the transaction that was broadcast.
341        #[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    /// Signals that the transaction has been confirmed on-chain and detected by the view server.
357    ///
358    /// Will not be sent unless await_detection was true.
359    #[derive(Clone, PartialEq, ::prost::Message)]
360    pub struct Confirmed {
361        /// The hash of the transaction that was broadcast.
362        #[prost(message, optional, tag = "1")]
363        pub id: ::core::option::Option<
364            super::super::super::core::txhash::v1::TransactionId,
365        >,
366        /// The height in which the transaction was detected as included in the chain, if any.
367        #[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    /// The expiry height for the requested TransactionPlan
401    #[prost(uint64, tag = "1")]
402    pub expiry_height: u64,
403    /// The memo for the requested TransactionPlan.
404    /// The memo must be unspecified unless `outputs` is nonempty.
405    #[prost(message, optional, tag = "3")]
406    pub memo: ::core::option::Option<super::super::core::transaction::v1::MemoPlaintext>,
407    /// If present, only spends funds from the given account.
408    #[prost(message, optional, tag = "4")]
409    pub source: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
410    /// Request contents
411    #[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    /// The epoch index of the transaction being planned.
468    #[deprecated]
469    #[prost(uint64, tag = "200")]
470    pub epoch_index: u64,
471    /// The epoch of the transaction being planned.
472    #[prost(message, optional, tag = "201")]
473    pub epoch: ::core::option::Option<super::super::core::component::sct::v1::Epoch>,
474    /// Specifies either that the planner should compute fees automatically or that it should use a fixed fee amount.
475    #[prost(oneof = "transaction_planner_request::FeeMode", tags = "100, 101")]
476    pub fee_mode: ::core::option::Option<transaction_planner_request::FeeMode>,
477}
478/// Nested message and enum types in `TransactionPlannerRequest`.
479pub mod transaction_planner_request {
480    /// Request message subtypes
481    #[derive(Clone, PartialEq, ::prost::Message)]
482    pub struct Output {
483        /// The amount and denomination in which the Output is issued.
484        #[prost(message, optional, tag = "1")]
485        pub value: ::core::option::Option<super::super::super::core::asset::v1::Value>,
486        /// The address to which Output will be sent.
487        #[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        /// The input amount and denomination in which the Spend is issued.
505        #[prost(message, optional, tag = "1")]
506        pub value: ::core::option::Option<super::super::super::core::asset::v1::Value>,
507        /// The source address from which the Spend will be sent.
508        #[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        /// The input amount and denomination to be traded in the Swap.
526        #[prost(message, optional, tag = "1")]
527        pub value: ::core::option::Option<super::super::super::core::asset::v1::Value>,
528        /// The denomination to be received as a Output of the Swap.
529        #[prost(message, optional, tag = "2")]
530        pub target_asset: ::core::option::Option<
531            super::super::super::core::asset::v1::AssetId,
532        >,
533        /// The pre-paid fee to be paid for claiming the Swap outputs.
534        #[prost(message, optional, tag = "3")]
535        pub fee: ::core::option::Option<
536            super::super::super::core::component::fee::v1::Fee,
537        >,
538        /// The address to which swap claim output will be sent.
539        #[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        /// SwapCommitment to identify the Swap to be claimed.
557        /// Use the commitment from the Swap message:
558        /// penumbra.core.component.dex.v1.Swap.body.payload.commitment.
559        #[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        /// The identity key of the validator to finish undelegating from.
615        #[prost(message, optional, tag = "1")]
616        pub validator_identity: ::core::option::Option<
617            super::super::super::core::keys::v1::IdentityKey,
618        >,
619        /// The epoch in which unbonding began, used to verify the penalty.
620        #[deprecated]
621        #[prost(uint64, tag = "2")]
622        pub start_epoch_index: u64,
623        /// The penalty applied to undelegation, in bps^2 (10e-8).
624        /// In the happy path (no slashing), this is 0.
625        #[prost(message, optional, tag = "3")]
626        pub penalty: ::core::option::Option<
627            super::super::super::core::component::stake::v1::Penalty,
628        >,
629        /// The amount of unbonding tokens to claim.
630        /// This is a bare number because its denom is determined by the preceding data.
631        #[prost(message, optional, tag = "4")]
632        pub unbonding_amount: ::core::option::Option<
633            super::super::super::core::num::v1::Amount,
634        >,
635        /// The height at which unbonding began.
636        #[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        /// Contains the data defining the position, sufficient to compute its `PositionId`.
652        ///
653        /// Positions are immutable, so the `PositionData` (and hence the `PositionId`)
654        /// are unchanged over the entire lifetime of the position.
655        #[prost(message, optional, tag = "1")]
656        pub position: ::core::option::Option<
657            super::super::super::core::component::dex::v1::Position,
658        >,
659        /// Optionally, provide position metadata to encrypt.
660        #[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        /// The position to close.
678        #[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        /// The position to withdraw.
696        #[prost(message, optional, tag = "1")]
697        pub position_id: ::core::option::Option<
698            super::super::super::core::component::dex::v1::PositionId,
699        >,
700        /// The position's final reserves.
701        #[prost(message, optional, tag = "2")]
702        pub reserves: ::core::option::Option<
703            super::super::super::core::component::dex::v1::Reserves,
704        >,
705        /// The trading pair of the position.
706        #[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        /// The description of the auction to schedule.
724        #[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        /// The unique id of the auction to close.
744        #[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        /// The auction to withdraw funds from.
762        #[prost(message, optional, tag = "1")]
763        pub auction_id: ::core::option::Option<
764            super::super::super::core::component::auction::v1::AuctionId,
765        >,
766        /// The sequence number of the withdrawal.
767        #[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        /// The proposal being voted on.
785        #[prost(uint64, tag = "1")]
786        pub proposal: u64,
787        /// The vote.
788        #[prost(message, optional, tag = "2")]
789        pub vote: ::core::option::Option<
790            super::super::super::core::component::governance::v1::Vote,
791        >,
792        /// The block height at which the proposal started voting.
793        #[prost(uint64, tag = "3")]
794        pub start_block_height: u64,
795        /// The position of the state commitment tree at which the proposal is considered to have started voting.
796        #[prost(uint64, tag = "4")]
797        pub start_position: u64,
798        /// The validators rate data for the proposal.
799        #[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        /// The asset the user wants to vote for.
817        #[prost(message, optional, tag = "1")]
818        pub incentivized: ::core::option::Option<
819            super::super::super::core::asset::v1::Denom,
820        >,
821        /// The address the user wants potential rewards to go to.
822        #[prost(message, optional, tag = "2")]
823        pub rewards_recipient: ::core::option::Option<
824            super::super::super::core::keys::v1::Address,
825        >,
826        /// The note containing the staked note used for voting.
827        #[prost(message, repeated, tag = "3")]
828        pub staked_notes: ::prost::alloc::vec::Vec<super::SpendableNoteRecord>,
829        /// The epoch index of the tournament.
830        #[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    /// Specifies either that the planner should compute fees automatically or that it should use a fixed fee amount.
846    #[derive(Clone, PartialEq, ::prost::Oneof)]
847    pub enum FeeMode {
848        /// Automatically compute a fee based on gas use.
849        #[prost(message, tag = "100")]
850        AutoFee(super::super::super::core::component::fee::v1::FeeTier),
851        /// A manually set fee, rather than automatically computing a fee based on gas use.
852        #[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    /// Will be absent if given an address not viewable by this viewing service
960    #[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    /// If present, filter balances to only include the account specified by the `AddressIndex`.
1010    #[prost(message, optional, tag = "1")]
1011    pub account_filter: ::core::option::Option<
1012        super::super::core::keys::v1::AddressIndex,
1013    >,
1014    /// If present, filter balances to only include the specified asset ID.
1015    #[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: use `account_address` instead.
1031    #[deprecated]
1032    #[prost(message, optional, tag = "1")]
1033    pub account: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
1034    /// Deprecated: use `balance_view` instead.
1035    #[deprecated]
1036    #[prost(message, optional, tag = "2")]
1037    pub balance: ::core::option::Option<super::super::core::asset::v1::Value>,
1038    /// The default address for the account.
1039    ///
1040    /// Note that the returned balance is for all funds sent to the account,
1041    /// not just funds sent to its default address.
1042    #[prost(message, optional, tag = "3")]
1043    pub account_address: ::core::option::Option<
1044        super::super::core::keys::v1::AddressView,
1045    >,
1046    /// The account's balance, with metadata.
1047    #[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/// Requests sync status of the view service.
1061#[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/// Returns the status of the view service and whether it is synchronized with the chain state.
1074#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1075pub struct StatusResponse {
1076    /// The height the view service has synchronized to so far when doing a full linear sync
1077    #[prost(uint64, tag = "1")]
1078    pub full_sync_height: u64,
1079    /// The height the view service has synchronized to so far when doing a partial sync
1080    #[prost(uint64, tag = "2")]
1081    pub partial_sync_height: u64,
1082    /// Whether the view service is catching up with the chain state
1083    #[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/// Requests streaming updates on the sync height until the view service is synchronized.
1097#[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/// A streaming sync status update
1110#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1111pub struct StatusStreamResponse {
1112    /// The latest known block height
1113    #[prost(uint64, tag = "1")]
1114    pub latest_known_block_height: u64,
1115    /// The height the view service has synchronized to so far when doing a full linear sync
1116    #[prost(uint64, tag = "2")]
1117    pub full_sync_height: u64,
1118    /// The height the view service has synchronized to so far when doing a partial sync
1119    #[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/// A query for notes known by the view service.
1133///
1134/// This message uses the fact that all proto fields are optional
1135/// to allow various filtering on the returned notes.
1136#[derive(Clone, PartialEq, ::prost::Message)]
1137pub struct NotesRequest {
1138    /// If set, return spent notes as well as unspent notes.
1139    #[prost(bool, tag = "2")]
1140    pub include_spent: bool,
1141    /// If set, only return notes with the specified asset id.
1142    #[prost(message, optional, tag = "3")]
1143    pub asset_id: ::core::option::Option<super::super::core::asset::v1::AssetId>,
1144    /// If set, only return notes with the specified address incore.component.dex.v1.
1145    #[prost(message, optional, tag = "4")]
1146    pub address_index: ::core::option::Option<
1147        super::super::core::keys::v1::AddressIndex,
1148    >,
1149    /// If set, stop returning notes once the total exceeds this amount.
1150    ///
1151    /// Ignored if `asset_id` is unset or if `include_spent` is set.
1152    #[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/// A query for notes to be used for voting on a proposal.
1166#[derive(Clone, PartialEq, ::prost::Message)]
1167pub struct NotesForVotingRequest {
1168    /// The starting height of the proposal.
1169    #[prost(uint64, tag = "1")]
1170    pub votable_at_height: u64,
1171    /// If set, only return notes with the specified asset id.
1172    #[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    /// The transaction plan to witness
1190    #[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}
1248/// Nested message and enum types in `WitnessAndBuildResponse`.
1249pub mod witness_and_build_response {
1250    /// Signals that building is in progress.
1251    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
1252    pub struct BuildProgress {
1253        /// An approximate progress of the build, from 0 to 1.
1254        #[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    /// Signals that the transaction is complete.
1268    #[derive(Clone, PartialEq, ::prost::Message)]
1269    pub struct Complete {
1270        /// The finished transaction.
1271        #[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/// Requests all assets known to the view service.
1305#[derive(Clone, PartialEq, ::prost::Message)]
1306pub struct AssetsRequest {
1307    /// If set to false (default), returns all assets, regardless of whether the rest of the fields of
1308    /// the request indicate a filter.
1309    #[prost(bool, tag = "1")]
1310    pub filtered: bool,
1311    /// Include these specific denominations in the response.
1312    #[prost(message, repeated, tag = "2")]
1313    pub include_specific_denominations: ::prost::alloc::vec::Vec<
1314        super::super::core::asset::v1::Denom,
1315    >,
1316    /// Include all delegation tokens, to any validator, in the response.
1317    #[prost(bool, tag = "3")]
1318    pub include_delegation_tokens: bool,
1319    /// Include all unbonding tokens, from any validator, in the response.
1320    #[prost(bool, tag = "4")]
1321    pub include_unbonding_tokens: bool,
1322    /// Include all LP NFTs in the response.
1323    #[prost(bool, tag = "5")]
1324    pub include_lp_nfts: bool,
1325    /// Include all proposal NFTs in the response.
1326    #[prost(bool, tag = "6")]
1327    pub include_proposal_nfts: bool,
1328    /// Include all voting receipt tokens in the response.
1329    #[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/// Requests all assets known to the view service.
1343#[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/// Requests the current app parameters from the view service.
1359#[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/// Requests the current gas prices from the view service.
1387#[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    /// The current gas prices, in the preferred (native) token.
1402    #[prost(message, optional, tag = "1")]
1403    pub gas_prices: ::core::option::Option<
1404        super::super::core::component::fee::v1::GasPrices,
1405    >,
1406    /// Other gas prices for other accepted tokens.
1407    #[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/// Requests the current FMD parameters from the view service.
1423#[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    /// If set to true, waits to return until the requested note is detected.
1459    #[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    /// If set to true, waits to return until the requested swap is detected.
1494    #[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    /// The transaction hash to query for.
1586    #[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    /// If present, return only transactions after this height.
1602    #[prost(uint64, tag = "1")]
1603    pub start_height: u64,
1604    /// If present, return only transactions before this height.
1605    #[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    /// The height the transaction was included in a block, if known.
1621    #[prost(uint64, tag = "1")]
1622    pub height: u64,
1623    /// The hash of the transaction.
1624    #[prost(message, optional, tag = "2")]
1625    pub id: ::core::option::Option<super::super::core::txhash::v1::TransactionId>,
1626    /// The transaction data itself.
1627    #[prost(message, optional, tag = "3")]
1628    pub transaction: ::core::option::Option<
1629        super::super::core::transaction::v1::Transaction,
1630    >,
1631    /// The transaction perspective, as seen by this view server.
1632    #[prost(message, optional, tag = "4")]
1633    pub perspective: ::core::option::Option<
1634        super::super::core::transaction::v1::TransactionPerspective,
1635    >,
1636    /// A precomputed transaction view of `transaction` from `perspective`, included for convenience of clients that don't have support for viewing transactions on their own.
1637    #[prost(message, optional, tag = "5")]
1638    pub view: ::core::option::Option<
1639        super::super::core::transaction::v1::TransactionView,
1640    >,
1641    /// A short view of balances leaving and entering accounts, computed from transaction actions.
1642    #[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/// A note plaintext with associated metadata about its status.
1720#[derive(Clone, PartialEq, ::prost::Message)]
1721pub struct SpendableNoteRecord {
1722    /// The note commitment, identifying the note.
1723    #[prost(message, optional, tag = "1")]
1724    pub note_commitment: ::core::option::Option<
1725        super::super::crypto::tct::v1::StateCommitment,
1726    >,
1727    /// The note plaintext itself.
1728    #[prost(message, optional, tag = "2")]
1729    pub note: ::core::option::Option<
1730        super::super::core::component::shielded_pool::v1::Note,
1731    >,
1732    /// A precomputed decryption of the note's address incore.component.dex.v1.
1733    #[prost(message, optional, tag = "3")]
1734    pub address_index: ::core::option::Option<
1735        super::super::core::keys::v1::AddressIndex,
1736    >,
1737    /// The note's nullifier.
1738    #[prost(message, optional, tag = "4")]
1739    pub nullifier: ::core::option::Option<
1740        super::super::core::component::sct::v1::Nullifier,
1741    >,
1742    /// The height at which the note was created.
1743    #[prost(uint64, tag = "5")]
1744    pub height_created: u64,
1745    /// Records whether the note was spent (and if so, at what height).
1746    #[prost(uint64, tag = "6")]
1747    pub height_spent: u64,
1748    /// The note position.
1749    #[prost(uint64, tag = "7")]
1750    pub position: u64,
1751    /// The source of the note
1752    #[prost(message, optional, tag = "8")]
1753    pub source: ::core::option::Option<
1754        super::super::core::component::sct::v1::CommitmentSource,
1755    >,
1756    /// The sender's return address, if known.
1757    #[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    /// If present, return only positions with this position state.
1812    #[prost(message, optional, tag = "1")]
1813    pub position_state: ::core::option::Option<
1814        super::super::core::component::dex::v1::PositionState,
1815    >,
1816    /// If present, return only positions for this trading pair.
1817    #[prost(message, optional, tag = "2")]
1818    pub trading_pair: ::core::option::Option<
1819        super::super::core::component::dex::v1::TradingPair,
1820    >,
1821    /// If present, return only positions for this subaccount index.
1822    #[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    /// The subaccount this position belongs to.
1842    #[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/// Requests information on an asset by asset id
1856#[derive(Clone, PartialEq, ::prost::Message)]
1857pub struct AssetMetadataByIdRequest {
1858    /// The asset id to request information on.
1859    #[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    /// If present, information on the requested asset.
1875    ///
1876    /// If the requested asset was unknown, this field will not be present.
1877    #[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/// Requests `ValueView`s of delegation tokens for the given address index. The
1891/// returned `ValueView`s will include the `ValidatorInfo` for the delegated
1892/// validator in their `extended_metadata` fields.
1893#[derive(Clone, PartialEq, ::prost::Message)]
1894pub struct DelegationsByAddressIndexRequest {
1895    /// The address index to fetch delegation balances for.
1896    #[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}
1903/// Nested message and enum types in `DelegationsByAddressIndexRequest`.
1904pub 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        /// By default, returns delegations for all active validators. For validators
1919        /// that the given address index has no delegation tokens for, a `ValueView`
1920        /// with a balance of `0` will be returned.
1921        Unspecified = 0,
1922        /// Returns only delegations to active validators that the given address
1923        /// index holds delegation tokens for.
1924        AllActiveWithNonzeroBalances = 1,
1925        /// Return delegations for all validators, whether active or not. For
1926        /// validators that the given address index has no delegation tokens for, a
1927        /// `ValueView` with a balance of `0` will be returned.
1928        All = 2,
1929    }
1930    impl Filter {
1931        /// String value of the enum field names used in the ProtoBuf definition.
1932        ///
1933        /// The values are not transformed in any way and thus are considered stable
1934        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1935        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        /// Creates an enum from field names used in the ProtoBuf definition.
1945        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/// Contains a `ValueView` of delegation tokens for the requested address index.
1968/// The `ValueView` includes the `ValidatorInfo` for the delegated validator in
1969/// cits `extended_metadata` field.
1970#[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/// Requests unbonding tokens for a given address index, with optional filtering
1986/// for whether the tokens are currently claimable.
1987#[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    /// The address index to fetch unbonding tokens for.
1995    #[prost(message, optional, tag = "2")]
1996    pub address_index: ::core::option::Option<
1997        super::super::core::keys::v1::AddressIndex,
1998    >,
1999}
2000/// Nested message and enum types in `UnbondingTokensByAddressIndexRequest`.
2001pub 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        /// Return all unbonding tokens, regardless of whether they're claimable
2016        /// right now.
2017        Unspecified = 0,
2018        /// Return all unbonding tokens that are currently claimable. This includes:
2019        ///
2020        /// * tokens that have passed the `unbonding_delay` (from `StakeParameters`)
2021        /// * tokens for unbonded validators
2022        Claimable = 1,
2023        /// Return all unbonding tokens that are not yet claimable, because they are
2024        /// still in the `unbonding_delay` (from `StakeParameters`) period.
2025        NotYetClaimable = 2,
2026    }
2027    impl Filter {
2028        /// String value of the enum field names used in the ProtoBuf definition.
2029        ///
2030        /// The values are not transformed in any way and thus are considered stable
2031        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2032        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        /// Creates an enum from field names used in the ProtoBuf definition.
2040        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/// Returns unbonding tokens for the given address index, optionally filtered by
2061/// whether the tokens are currently claimable.
2062#[derive(Clone, PartialEq, ::prost::Message)]
2063pub struct UnbondingTokensByAddressIndexResponse {
2064    /// A `ValueView` representing the amount of the given unbonding token.
2065    #[prost(message, optional, tag = "1")]
2066    pub value_view: ::core::option::Option<super::super::core::asset::v1::ValueView>,
2067    /// Whether the unbonding token is currently claimable. This will only be
2068    /// `true` if the `unbonding_delay` (from `StakeParameters`) has passed or the
2069    /// validator has unbonded.
2070    #[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/// Requests the latest swaps controlled by the user's wallet.
2084#[derive(Clone, PartialEq, ::prost::Message)]
2085pub struct LatestSwapsRequest {
2086    /// If present, filter balances to only include the account specified by the `AddressIndex`.
2087    #[prost(message, optional, tag = "1")]
2088    pub account_filter: ::core::option::Option<
2089        super::super::core::keys::v1::AddressIndex,
2090    >,
2091    /// If present, filter balances to only include trading activity on the specified pair.
2092    #[prost(message, optional, tag = "2")]
2093    pub pair: ::core::option::Option<
2094        super::super::core::component::dex::v1::DirectedTradingPair,
2095    >,
2096    /// If present, limit the responses to activity that occurred after this block height.
2097    #[prost(uint64, tag = "3")]
2098    pub after_height: u64,
2099    /// Limit the response to the last entries within `response_limit`.
2100    #[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    /// The trading pair involved in this swap.
2116    #[prost(message, optional, tag = "1")]
2117    pub pair: ::core::option::Option<
2118        super::super::core::component::dex::v1::DirectedTradingPair,
2119    >,
2120    /// The input value for the swap.
2121    #[prost(message, optional, tag = "2")]
2122    pub input: ::core::option::Option<super::super::core::asset::v1::Value>,
2123    /// The output value received from the swap.
2124    #[prost(message, optional, tag = "3")]
2125    pub output: ::core::option::Option<super::super::core::asset::v1::Value>,
2126    /// The block height at which this swap occurred.
2127    #[prost(uint64, tag = "4")]
2128    pub block_height: u64,
2129    /// The hash of the transaction that was broadcast.
2130    #[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/// Request bundles of liquidity positions by trading pair / subaccount / strategy.
2144#[derive(Clone, PartialEq, ::prost::Message)]
2145pub struct LpPositionBundleRequest {
2146    /// Filter by subaccount index.
2147    #[prost(message, optional, tag = "1")]
2148    pub subaccount: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
2149    /// Filter by trading pair.
2150    #[prost(message, optional, tag = "2")]
2151    pub trading_pair: ::core::option::Option<
2152        super::super::core::component::dex::v1::TradingPair,
2153    >,
2154    /// Filter by strategy, and also identifier if present.
2155    #[prost(message, optional, tag = "3")]
2156    pub position_metadata: ::core::option::Option<
2157        super::super::core::component::dex::v1::PositionMetadata,
2158    >,
2159    /// Filter by strategy state.
2160    #[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}
2180/// Nested message and enum types in `LpPositionBundleResponse`.
2181pub mod lp_position_bundle_response {
2182    #[derive(Clone, PartialEq, ::prost::Message)]
2183    pub struct Entry {
2184        /// The trading pair for which this strategy is defined.
2185        #[prost(message, optional, tag = "1")]
2186        pub trading_pair: ::core::option::Option<
2187            super::super::super::core::component::dex::v1::TradingPair,
2188        >,
2189        /// The subaccount index for which this strategy is defined.
2190        #[prost(message, optional, tag = "2")]
2191        pub subaccount: ::core::option::Option<
2192            super::super::super::core::keys::v1::AddressIndex,
2193        >,
2194        /// The LP strategy metadata.
2195        #[prost(message, optional, tag = "3")]
2196        pub position_metadata: ::core::option::Option<
2197            super::super::super::core::component::dex::v1::PositionMetadata,
2198        >,
2199        /// The strategy state (e.g., open, closed, etc.).
2200        #[prost(message, optional, tag = "4")]
2201        pub position_state: ::core::option::Option<
2202            super::super::super::core::component::dex::v1::PositionState,
2203        >,
2204        /// The position id for the LP strategy.
2205        #[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/// Request a list of LP strategies (e.g, for a UI to display a catalogue of strategies).
2232#[derive(Clone, PartialEq, ::prost::Message)]
2233pub struct LpStrategyCatalogRequest {
2234    /// Filter by subaccount index.
2235    #[prost(message, optional, tag = "1")]
2236    pub subaccount: ::core::option::Option<super::super::core::keys::v1::AddressIndex>,
2237    /// Filter by trading pair.
2238    #[prost(message, optional, tag = "2")]
2239    pub trading_pair: ::core::option::Option<
2240        super::super::core::component::dex::v1::TradingPair,
2241    >,
2242    /// Filter by strategy.
2243    #[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}
2265/// Nested message and enum types in `LpStrategyCatalogResponse`.
2266pub mod lp_strategy_catalog_response {
2267    #[derive(Clone, PartialEq, ::prost::Message)]
2268    pub struct StrategyEntry {
2269        /// The trading pair for which this strategy is defined.
2270        #[prost(message, optional, tag = "1")]
2271        pub trading_pair: ::core::option::Option<
2272            super::super::super::core::component::dex::v1::TradingPair,
2273        >,
2274        /// The subaccount index for which this strategy is defined.
2275        #[prost(message, optional, tag = "2")]
2276        pub subaccount: ::core::option::Option<
2277            super::super::super::core::keys::v1::AddressIndex,
2278        >,
2279        /// The LP strategy metadata.
2280        #[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/// Generated client implementations.
2307#[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    /// The view RPC is used by a view client, who wants to do some
2319    /// transaction-related actions, to request data from a view service, which is
2320    /// responsible for synchronizing and scanning the public chain state with one or
2321    /// more full viewing keys.
2322    #[derive(Debug, Clone)]
2323    pub struct ViewServiceClient<T> {
2324        inner: tonic::client::Grpc<T>,
2325    }
2326    impl ViewServiceClient<tonic::transport::Channel> {
2327        /// Attempt to create a new client by connecting to a given endpoint.
2328        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        /// Compress requests with the given encoding.
2372        ///
2373        /// This requires the server to support it otherwise it might respond with an
2374        /// error.
2375        #[must_use]
2376        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2377            self.inner = self.inner.send_compressed(encoding);
2378            self
2379        }
2380        /// Enable decompressing responses.
2381        #[must_use]
2382        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2383            self.inner = self.inner.accept_compressed(encoding);
2384            self
2385        }
2386        /// Limits the maximum size of a decoded message.
2387        ///
2388        /// Default: `4MB`
2389        #[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        /// Limits the maximum size of an encoded message.
2395        ///
2396        /// Default: `usize::MAX`
2397        #[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        /// Get current status of chain sync
2403        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        /// Stream sync status updates until the view service has caught up with the chain.
2425        /// Returns a stream of `StatusStreamResponse`s.
2426        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        /// Queries for notes that have been accepted by the chain.
2451        /// Returns a stream of `NotesResponse`s.
2452        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        /// Returns a stream of `NotesForVotingResponse`s.
2477        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        /// Queries for metadata about known assets.
2504        /// Returns a stream of `AssetsResponse`s.
2505        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        /// Query for metadata about a specific asset, by asset ID.
2530        ///
2531        /// This is the same as the method on the shielded pool's `QueryService`, but exposing it
2532        /// here allows a view server to provide more specific or opinionated asset metadata -- like
2533        /// using an asset registry to provide tickers, symbols, etc.
2534        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        /// Query for the current app parameters.
2561        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        /// Query for the current gas prices.
2588        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        /// Query for the current FMD parameters.
2613        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        /// Query for an address given an address index
2640        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        /// Returns the transparent address for the user's wallet.
2667        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        /// Query for wallet id
2694        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        /// Query for an address given an address index
2719        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        /// Query for an ephemeral address
2746        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        /// Query for balance of a given address.
2773        /// Returns a stream of `BalancesResponses`.
2774        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        /// Query for a note by its note commitment, optionally waiting until the note is detected.
2799        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        /// Query for a swap by its swap commitment, optionally waiting until the swap is detected.
2826        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        /// Query for all unclaimed swaps.
2853        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        /// Query for whether a nullifier has been spent, optionally waiting until it is spent.
2880        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        /// Query for a given transaction by its hash.
2907        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        /// Query for the full transactions in the given range of blocks.
2937        /// Returns a stream of `TransactionInfoResponse`s.
2938        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        /// Query for owned position IDs for the given trading pair and in the given position state.
2965        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        /// Translates a high-level intent ("send X funds to Y address") into a complete transaction plan.
2992        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        /// Returns authentication data for the given transaction plan.
3019        ///
3020        /// This method takes a complete transaction plan, so that the client can get a
3021        /// consistent set of authentication paths to a common root for the entire
3022        /// transaction.  (Otherwise, if a client made multiple requests, the wallet
3023        /// service could have advanced the state commitment tree  between queries).
3024        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        /// Like `Witness`, but immediately uses the witness data to build (prove) the transaction.
3049        ///
3050        /// This method is useful for clients that can't easily do proving themselves, either because
3051        /// they're not written in Rust and can't easily import the proving code, or because they don't
3052        /// have access to proving keys, or some other reason.
3053        ///
3054        /// This method streams status updates to the caller before finally returning the transaction.
3055        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        /// Authorize a transaction plan and build the transaction.
3082        ///
3083        /// This method is only supported on view servers that have access to a custody
3084        /// service.  Otherwise, it will fail.
3085        ///
3086        /// Penumbra's transaction authorization mechanism is designed so transactions
3087        /// can be signed and built (proved) concurrently. This allows implementations
3088        /// to, e.g., start proving optimistically while presenting the user with an
3089        /// approval dialog.
3090        ///
3091        /// This method streams status updates to the caller before finally returning the transaction.
3092        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        /// Broadcast a transaction to the network, optionally waiting for full confirmation.
3119        ///
3120        /// This method streams status updates to the caller before finally returning confirmation.
3121        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        /// Get delegation tokens for a given address index. Each delegation token will
3153        /// be represented by a `ValueView` with the given address index's balance of
3154        /// that token. Each `ValueView`'s `extended_metadata` field will contain the
3155        /// `ValidatorInfo` of the delegated validator.
3156        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        /// Get unbonding tokens for the given address index, optionally filtered by
3188        /// whether the tokens are currently claimable.
3189        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        /// Gets the auctions controlled by the user's wallet.
3221        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        /// Gets the latest swaps controlled by the user's wallet.
3246        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        /// Gets a list of votes cast in the liquidity tournament for a specific epoch or up to certain block height.
3271        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        /// Gets the spendable note records that are eligible for voting in the current epoch.
3298        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        /// Request bundles of liquidity positions by trading pair / subaccount / strategy.
3325        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        /// Request a list of LP strategies (e.g, for a UI to display a catalogue of strategies).
3352        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/// Generated server implementations.
3381#[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    /// Generated trait containing gRPC methods that should be implemented for use with ViewServiceServer.
3392    #[async_trait]
3393    pub trait ViewService: std::marker::Send + std::marker::Sync + 'static {
3394        /// Get current status of chain sync
3395        async fn status(
3396            &self,
3397            request: tonic::Request<super::StatusRequest>,
3398        ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status>;
3399        /// Server streaming response type for the StatusStream method.
3400        type StatusStreamStream: tonic::codegen::tokio_stream::Stream<
3401                Item = std::result::Result<super::StatusStreamResponse, tonic::Status>,
3402            >
3403            + std::marker::Send
3404            + 'static;
3405        /// Stream sync status updates until the view service has caught up with the chain.
3406        /// Returns a stream of `StatusStreamResponse`s.
3407        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        /// Server streaming response type for the Notes method.
3415        type NotesStream: tonic::codegen::tokio_stream::Stream<
3416                Item = std::result::Result<super::NotesResponse, tonic::Status>,
3417            >
3418            + std::marker::Send
3419            + 'static;
3420        /// Queries for notes that have been accepted by the chain.
3421        /// Returns a stream of `NotesResponse`s.
3422        async fn notes(
3423            &self,
3424            request: tonic::Request<super::NotesRequest>,
3425        ) -> std::result::Result<tonic::Response<Self::NotesStream>, tonic::Status>;
3426        /// Server streaming response type for the NotesForVoting method.
3427        type NotesForVotingStream: tonic::codegen::tokio_stream::Stream<
3428                Item = std::result::Result<super::NotesForVotingResponse, tonic::Status>,
3429            >
3430            + std::marker::Send
3431            + 'static;
3432        /// Returns a stream of `NotesForVotingResponse`s.
3433        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        /// Server streaming response type for the Assets method.
3441        type AssetsStream: tonic::codegen::tokio_stream::Stream<
3442                Item = std::result::Result<super::AssetsResponse, tonic::Status>,
3443            >
3444            + std::marker::Send
3445            + 'static;
3446        /// Queries for metadata about known assets.
3447        /// Returns a stream of `AssetsResponse`s.
3448        async fn assets(
3449            &self,
3450            request: tonic::Request<super::AssetsRequest>,
3451        ) -> std::result::Result<tonic::Response<Self::AssetsStream>, tonic::Status>;
3452        /// Query for metadata about a specific asset, by asset ID.
3453        ///
3454        /// This is the same as the method on the shielded pool's `QueryService`, but exposing it
3455        /// here allows a view server to provide more specific or opinionated asset metadata -- like
3456        /// using an asset registry to provide tickers, symbols, etc.
3457        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        /// Query for the current app parameters.
3465        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        /// Query for the current gas prices.
3473        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        /// Query for the current FMD parameters.
3481        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        /// Query for an address given an address index
3489        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        /// Returns the transparent address for the user's wallet.
3497        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        /// Query for wallet id
3505        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        /// Query for an address given an address index
3513        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        /// Query for an ephemeral address
3521        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        /// Server streaming response type for the Balances method.
3529        type BalancesStream: tonic::codegen::tokio_stream::Stream<
3530                Item = std::result::Result<super::BalancesResponse, tonic::Status>,
3531            >
3532            + std::marker::Send
3533            + 'static;
3534        /// Query for balance of a given address.
3535        /// Returns a stream of `BalancesResponses`.
3536        async fn balances(
3537            &self,
3538            request: tonic::Request<super::BalancesRequest>,
3539        ) -> std::result::Result<tonic::Response<Self::BalancesStream>, tonic::Status>;
3540        /// Query for a note by its note commitment, optionally waiting until the note is detected.
3541        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        /// Query for a swap by its swap commitment, optionally waiting until the swap is detected.
3549        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        /// Server streaming response type for the UnclaimedSwaps method.
3557        type UnclaimedSwapsStream: tonic::codegen::tokio_stream::Stream<
3558                Item = std::result::Result<super::UnclaimedSwapsResponse, tonic::Status>,
3559            >
3560            + std::marker::Send
3561            + 'static;
3562        /// Query for all unclaimed swaps.
3563        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        /// Query for whether a nullifier has been spent, optionally waiting until it is spent.
3571        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        /// Query for a given transaction by its hash.
3579        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        /// Server streaming response type for the TransactionInfo method.
3587        type TransactionInfoStream: tonic::codegen::tokio_stream::Stream<
3588                Item = std::result::Result<super::TransactionInfoResponse, tonic::Status>,
3589            >
3590            + std::marker::Send
3591            + 'static;
3592        /// Query for the full transactions in the given range of blocks.
3593        /// Returns a stream of `TransactionInfoResponse`s.
3594        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        /// Server streaming response type for the OwnedPositionIds method.
3602        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        /// Query for owned position IDs for the given trading pair and in the given position state.
3611        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        /// Translates a high-level intent ("send X funds to Y address") into a complete transaction plan.
3619        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        /// Returns authentication data for the given transaction plan.
3627        ///
3628        /// This method takes a complete transaction plan, so that the client can get a
3629        /// consistent set of authentication paths to a common root for the entire
3630        /// transaction.  (Otherwise, if a client made multiple requests, the wallet
3631        /// service could have advanced the state commitment tree  between queries).
3632        async fn witness(
3633            &self,
3634            request: tonic::Request<super::WitnessRequest>,
3635        ) -> std::result::Result<tonic::Response<super::WitnessResponse>, tonic::Status>;
3636        /// Server streaming response type for the WitnessAndBuild method.
3637        type WitnessAndBuildStream: tonic::codegen::tokio_stream::Stream<
3638                Item = std::result::Result<super::WitnessAndBuildResponse, tonic::Status>,
3639            >
3640            + std::marker::Send
3641            + 'static;
3642        /// Like `Witness`, but immediately uses the witness data to build (prove) the transaction.
3643        ///
3644        /// This method is useful for clients that can't easily do proving themselves, either because
3645        /// they're not written in Rust and can't easily import the proving code, or because they don't
3646        /// have access to proving keys, or some other reason.
3647        ///
3648        /// This method streams status updates to the caller before finally returning the transaction.
3649        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        /// Server streaming response type for the AuthorizeAndBuild method.
3657        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        /// Authorize a transaction plan and build the transaction.
3666        ///
3667        /// This method is only supported on view servers that have access to a custody
3668        /// service.  Otherwise, it will fail.
3669        ///
3670        /// Penumbra's transaction authorization mechanism is designed so transactions
3671        /// can be signed and built (proved) concurrently. This allows implementations
3672        /// to, e.g., start proving optimistically while presenting the user with an
3673        /// approval dialog.
3674        ///
3675        /// This method streams status updates to the caller before finally returning the transaction.
3676        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        /// Server streaming response type for the BroadcastTransaction method.
3684        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        /// Broadcast a transaction to the network, optionally waiting for full confirmation.
3693        ///
3694        /// This method streams status updates to the caller before finally returning confirmation.
3695        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        /// Server streaming response type for the DelegationsByAddressIndex method.
3703        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        /// Get delegation tokens for a given address index. Each delegation token will
3712        /// be represented by a `ValueView` with the given address index's balance of
3713        /// that token. Each `ValueView`'s `extended_metadata` field will contain the
3714        /// `ValidatorInfo` of the delegated validator.
3715        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        /// Server streaming response type for the UnbondingTokensByAddressIndex method.
3723        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        /// Get unbonding tokens for the given address index, optionally filtered by
3732        /// whether the tokens are currently claimable.
3733        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        /// Server streaming response type for the Auctions method.
3741        type AuctionsStream: tonic::codegen::tokio_stream::Stream<
3742                Item = std::result::Result<super::AuctionsResponse, tonic::Status>,
3743            >
3744            + std::marker::Send
3745            + 'static;
3746        /// Gets the auctions controlled by the user's wallet.
3747        async fn auctions(
3748            &self,
3749            request: tonic::Request<super::AuctionsRequest>,
3750        ) -> std::result::Result<tonic::Response<Self::AuctionsStream>, tonic::Status>;
3751        /// Server streaming response type for the LatestSwaps method.
3752        type LatestSwapsStream: tonic::codegen::tokio_stream::Stream<
3753                Item = std::result::Result<super::LatestSwapsResponse, tonic::Status>,
3754            >
3755            + std::marker::Send
3756            + 'static;
3757        /// Gets the latest swaps controlled by the user's wallet.
3758        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        /// Server streaming response type for the TournamentVotes method.
3766        type TournamentVotesStream: tonic::codegen::tokio_stream::Stream<
3767                Item = std::result::Result<super::TournamentVotesResponse, tonic::Status>,
3768            >
3769            + std::marker::Send
3770            + 'static;
3771        /// Gets a list of votes cast in the liquidity tournament for a specific epoch or up to certain block height.
3772        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        /// Server streaming response type for the LqtVotingNotes method.
3780        type LqtVotingNotesStream: tonic::codegen::tokio_stream::Stream<
3781                Item = std::result::Result<super::LqtVotingNotesResponse, tonic::Status>,
3782            >
3783            + std::marker::Send
3784            + 'static;
3785        /// Gets the spendable note records that are eligible for voting in the current epoch.
3786        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        /// Server streaming response type for the LpPositionBundle method.
3794        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        /// Request bundles of liquidity positions by trading pair / subaccount / strategy.
3803        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        /// Server streaming response type for the LpStrategyCatalog method.
3811        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        /// Request a list of LP strategies (e.g, for a UI to display a catalogue of strategies).
3820        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    /// The view RPC is used by a view client, who wants to do some
3829    /// transaction-related actions, to request data from a view service, which is
3830    /// responsible for synchronizing and scanning the public chain state with one or
3831    /// more full viewing keys.
3832    #[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        /// Enable decompressing requests with the given encoding.
3863        #[must_use]
3864        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
3865            self.accept_compression_encodings.enable(encoding);
3866            self
3867        }
3868        /// Compress responses with the given encoding, if the client supports it.
3869        #[must_use]
3870        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
3871            self.send_compression_encodings.enable(encoding);
3872            self
3873        }
3874        /// Limits the maximum size of a decoded message.
3875        ///
3876        /// Default: `4MB`
3877        #[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        /// Limits the maximum size of an encoded message.
3883        ///
3884        /// Default: `usize::MAX`
3885        #[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    /// Generated gRPC service name
5571    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}