diff --git a/Cargo.lock b/Cargo.lock
index adb3172100..2cfedfc1fb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4822,11 +4822,16 @@ version = "0.58.0"
 dependencies = [
  "anyhow",
  "async-trait",
+ "penumbra-asset",
  "penumbra-chain",
  "penumbra-component",
+ "penumbra-dex",
+ "penumbra-num",
  "penumbra-proto",
  "penumbra-shielded-pool",
+ "penumbra-stake",
  "penumbra-storage",
+ "proptest",
  "tendermint",
  "tracing",
 ]
diff --git a/crates/bin/pd/src/info/specific.rs b/crates/bin/pd/src/info/specific.rs
index 0e2c033dd9..3a0a86b931 100644
--- a/crates/bin/pd/src/info/specific.rs
+++ b/crates/bin/pd/src/info/specific.rs
@@ -52,8 +52,6 @@ use proto::client::v1alpha1::LiquidityPositionsByPriceRequest;
 use proto::client::v1alpha1::LiquidityPositionsByPriceResponse;
 use proto::client::v1alpha1::LiquidityPositionsRequest;
 use proto::client::v1alpha1::LiquidityPositionsResponse;
-use proto::client::v1alpha1::NextValidatorRateRequest;
-use proto::client::v1alpha1::NextValidatorRateResponse;
 use proto::client::v1alpha1::PrefixValueRequest;
 use proto::client::v1alpha1::PrefixValueResponse;
 use proto::client::v1alpha1::SimulateTradeRequest;
@@ -494,36 +492,6 @@ impl SpecificQueryService for Info {
         }
     }
 
-    #[instrument(skip(self, request))]
-    async fn next_validator_rate(
-        &self,
-        request: tonic::Request<NextValidatorRateRequest>,
-    ) -> Result<tonic::Response<NextValidatorRateResponse>, Status> {
-        let state = self.storage.latest_snapshot();
-        state
-            .check_chain_id(&request.get_ref().chain_id)
-            .await
-            .map_err(|e| tonic::Status::unknown(format!("chain_id not OK: {e}")))?;
-        let identity_key = request
-            .into_inner()
-            .identity_key
-            .ok_or_else(|| tonic::Status::invalid_argument("empty message"))?
-            .try_into()
-            .map_err(|_| tonic::Status::invalid_argument("invalid identity key"))?;
-
-        let rate_data = state
-            .next_validator_rate(&identity_key)
-            .await
-            .map_err(|e| tonic::Status::internal(e.to_string()))?;
-
-        match rate_data {
-            Some(r) => Ok(tonic::Response::new(NextValidatorRateResponse {
-                data: Some(r.into()),
-            })),
-            None => Err(Status::not_found("next validator rate not found")),
-        }
-    }
-
     #[instrument(skip(self, request))]
     /// Get the batch swap data associated with a given trading pair and height.
     async fn batch_swap_output_data(
diff --git a/crates/core/component/component/src/component.rs b/crates/core/component/component/src/component.rs
index 23fc6e89ff..ca1fffee78 100644
--- a/crates/core/component/component/src/component.rs
+++ b/crates/core/component/component/src/component.rs
@@ -18,7 +18,7 @@ pub trait Component {
     /// This method is called once per chain, and should only perform
     /// writes, since the backing tree for the [`State`] will
     /// be empty.
-    async fn init_chain<S: StateWrite>(state: S, app_state: &Self::AppState);
+    async fn init_chain<S: StateWrite>(_state: S, _app_state: &Self::AppState) {}
 
     /// Begins a new block, optionally inspecting the ABCI
     /// [`BeginBlock`](abci::request::BeginBlock) request.
@@ -31,9 +31,10 @@ pub trait Component {
     /// implementor MUST ensure that any clones of the `Arc` are dropped before
     /// it returns, so that `state.get_mut().is_some()` on completion.
     async fn begin_block<S: StateWrite + 'static>(
-        state: &mut Arc<S>,
-        begin_block: &abci::request::BeginBlock,
-    );
+        _state: &mut Arc<S>,
+        _begin_block: &abci::request::BeginBlock,
+    ) {
+    }
 
     /// Ends the block, optionally inspecting the ABCI
     /// [`EndBlock`](abci::request::EndBlock) request, and performing any batch
@@ -50,9 +51,10 @@ pub trait Component {
     /// implementor MUST ensure that any clones of the `Arc` are dropped before
     /// it returns, so that `state.get_mut().is_some()` on completion.
     async fn end_block<S: StateWrite + 'static>(
-        state: &mut Arc<S>,
-        end_block: &abci::request::EndBlock,
-    );
+        _state: &mut Arc<S>,
+        _end_block: &abci::request::EndBlock,
+    ) {
+    }
 
     /// Ends the epoch, applying component-specific state transitions that should occur when an epoch ends.
     ///
@@ -63,5 +65,7 @@ pub trait Component {
     /// called, `state.get_mut().is_some()`, i.e., the `Arc` is not shared.  The
     /// implementor MUST ensure that any clones of the `Arc` are dropped before
     /// it returns, so that `state.get_mut().is_some()` on completion.
-    async fn end_epoch<S: StateWrite + 'static>(state: &mut Arc<S>) -> Result<()>;
+    async fn end_epoch<S: StateWrite + 'static>(_state: &mut Arc<S>) -> Result<()> {
+        Ok(())
+    }
 }
diff --git a/crates/core/component/distributions/Cargo.toml b/crates/core/component/distributions/Cargo.toml
index 3b5d222931..b2d3534dc3 100644
--- a/crates/core/component/distributions/Cargo.toml
+++ b/crates/core/component/distributions/Cargo.toml
@@ -18,6 +18,10 @@ penumbra-storage = { path = "../../../storage", optional = true }
 penumbra-component = { path = "../component", optional = true }
 penumbra-chain = { path = "../chain", default-features = false }
 penumbra-shielded-pool = { path = "../shielded-pool", default-features = false }
+penumbra-stake = { path = "../stake", default-features = false }
+penumbra-dex = { path = "../dex", default-features = false }
+penumbra-num = { path = "../../num" }
+penumbra-asset = { path = "../../asset" }
 
 # Crates.io deps
 async-trait = "0.1.52"
@@ -26,3 +30,4 @@ tracing = "0.1"
 tendermint = "0.32.0"
 
 [dev-dependencies]
+proptest = "1"
\ No newline at end of file
diff --git a/crates/core/component/distributions/src/component.rs b/crates/core/component/distributions/src/component.rs
index 6475c011bb..2f475163cb 100644
--- a/crates/core/component/distributions/src/component.rs
+++ b/crates/core/component/distributions/src/component.rs
@@ -2,37 +2,207 @@ pub mod state_key;
 
 mod view;
 
-use std::sync::Arc;
+use std::{
+    fmt::{self, Display, Formatter},
+    sync::Arc,
+};
 
 use anyhow::Result;
 use async_trait::async_trait;
-use penumbra_chain::genesis;
+use penumbra_asset::{asset, STAKING_TOKEN_ASSET_ID};
+use penumbra_chain::{component::StateReadExt as _, genesis};
 use penumbra_component::Component;
-use penumbra_storage::StateWrite;
-use tendermint::abci;
+use penumbra_proto::{StateReadProto, StateWriteProto};
+use penumbra_storage::{StateRead, StateWrite};
+use tracing::instrument;
 pub use view::{StateReadExt, StateWriteExt};
 
+#[allow(unused_imports)]
+use penumbra_dex::{component::StateReadExt as _, component::StateWriteExt as _};
+use penumbra_stake::{component::StateWriteExt as _, StateReadExt as _};
+
 pub struct Distributions {}
 
 #[async_trait]
 impl Component for Distributions {
     type AppState = genesis::AppState;
 
-    async fn init_chain<S: StateWrite>(_state: S, _app_state: &Self::AppState) {}
+    #[instrument(name = "distributions", skip(state, app_state))]
+    async fn init_chain<S: StateWrite>(mut state: S, app_state: &Self::AppState) {
+        // Tally up the total issuance of the staking token from the genesis allocations, so that we
+        // can accurately track the total amount issued in the future.
+        let genesis_issuance = app_state
+            .allocations
+            .iter()
+            .filter(|alloc| {
+                // Filter only for allocations of the staking token
+                asset::REGISTRY.parse_denom(&alloc.denom).map(|d| d.id())
+                    == Some(*STAKING_TOKEN_ASSET_ID)
+            })
+            .fold(0u64, |sum, alloc| {
+                // Total the allocations
+                sum.checked_add(
+                    u128::from(alloc.amount)
+                        .try_into()
+                        .expect("genesis issuance does not overflow `u64`"),
+                )
+                .expect("genesis issuance does not overflow `u64`")
+            });
+        tracing::debug!(
+            "total genesis issuance of staking token: {}",
+            genesis_issuance
+        );
+        state.set_total_issued(genesis_issuance);
+    }
+
+    #[instrument(name = "distributions", skip(state))]
+    async fn end_epoch<S: StateWrite + 'static>(state: &mut Arc<S>) -> Result<()> {
+        let state = Arc::get_mut(state).expect("state `Arc` is unique");
+
+        // Get the remainders of issuances that couldn't be distributed last epoch, due to precision
+        // loss or lack of activity.
+        let staking_remainder: u64 = state.staking_issuance().await?;
+        let dex_remainder: u64 = 0; // TODO: get this from the dex once LP rewards are implemented
+
+        // Sum all the per-component remainders together, including any remainder in the
+        // distribution component itself left over undistributed in the previous epoch
+        let last_epoch_remainder =
+            staking_remainder
+                .checked_add(dex_remainder)
+                .ok_or_else(|| {
+                    anyhow::anyhow!("staking and dex remainders overflowed when added together")
+                })?;
+
+        // The remainder from the previous epoch could not be issued, so subtract it from the total
+        // issuance for all time.
+        let total_issued = state
+            .total_issued()
+            .await?
+            .checked_sub(last_epoch_remainder)
+            .expect(
+                "total issuance is greater than or equal to the remainder from the previous epoch",
+            );
+        state.set_total_issued(total_issued);
+
+        // Add the remainder from the previous epoch to the remainder carried over from before then.
+        let remainder = last_epoch_remainder
+            .checked_add(state.remainder().await?)
+            .expect("remainder does not overflow `u64`");
+
+        tracing::debug!(
+            ?remainder,
+            ?last_epoch_remainder,
+            ?staking_remainder,
+            ?dex_remainder,
+        );
+
+        // Clear out the remaining issuances, so that if we don't issue anything to one of them, we
+        // don't leave the remainder there.
+        state.set_staking_issuance(0);
+        // TODO: clear dex issuance
 
-    async fn begin_block<S: StateWrite + 'static>(
-        _state: &mut Arc<S>,
-        _begin_block: &abci::request::BeginBlock,
-    ) {
+        // Get the total issuance and new remainder for this epoch
+        let (issuance, remainder) = state.total_issuance_and_remainder(remainder).await?;
+
+        tracing::debug!(new_issuance = ?issuance, new_remainder = ?remainder);
+
+        // Set the remainder to be carried over to the next epoch
+        state.set_remainder(remainder);
+
+        // Set the cumulative total issuance (pending receipt of remainders, which may decrease it
+        // next epoch)
+        state.set_total_issued(total_issued + issuance);
+
+        // Determine the allocation of the issuance between the different components: this returns a
+        // set of weights, which we'll use to scale the total issuance
+        let weights = state.issuance_weights().await?;
+
+        // Allocate the issuance according to the weights
+        if let Some(allocation) = penumbra_num::allocate(issuance.into(), weights) {
+            for (component, issuance) in allocation {
+                use ComponentName::*;
+                let issuance: u64 = issuance.try_into().expect("total issuance is within `u64`");
+                tracing::debug!(%component, ?issuance, "issuing tokens to component"
+                );
+                match component {
+                    Staking => state.set_staking_issuance(issuance),
+                    Dex => todo!("set dex issuance"),
+                }
+            }
+        }
+
+        Ok(())
     }
+}
 
-    async fn end_block<S: StateWrite + 'static>(
-        _state: &mut Arc<S>,
-        _end_block: &abci::request::EndBlock,
-    ) {
+#[allow(dead_code)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+enum ComponentName {
+    Staking,
+    Dex,
+}
+
+impl Display for ComponentName {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            ComponentName::Staking => write!(f, "staking"),
+            ComponentName::Dex => write!(f, "dex"),
+        }
     }
+}
 
-    async fn end_epoch<S: StateWrite + 'static>(_state: &mut Arc<S>) -> Result<()> {
-        Ok(())
+#[async_trait]
+trait DistributionsImpl
+where
+    Self: StateRead + StateWrite,
+{
+    // Compute the total issuance for this epoch, and the remainder that will be carried over to
+    // the next epoch, given the remainder that was carried forward from the preceding epoch.
+    async fn total_issuance_and_remainder(&self, remainder: u64) -> Result<(u64, u64)> {
+        // This currently computes the new issuance by multiplying the total staking token ever
+        // issued by the base reward rate. This is a stand-in for a more accurate and good model of
+        // issuance, which will be implemented later. For now, this inflates the total issuance of
+        // staking tokens by a fixed ratio per epoch.
+        let base_reward_rate = self.get_chain_params().await?.base_reward_rate;
+        let total_issued = self.total_issued().await?;
+        const BPS_SQUARED: u64 = 1_0000_0000; // reward rate is measured in basis points squared
+        let new_issuance = total_issued * base_reward_rate / BPS_SQUARED;
+        let issuance = new_issuance + remainder;
+        Ok((issuance, 0))
+    }
+
+    // Determine in each epoch what the relative weight of issuance per component should be. The
+    // returned list of weights is used to allocate the total issuance between the different
+    // components, and does not need to sum to any particular total; it will be rescaled to the
+    // total issuance determined by `total_issuance_and_remainder`.
+    async fn issuance_weights(&self) -> Result<Vec<(ComponentName, u128)>> {
+        // Currently, only issue staking rewards:
+        Ok(vec![(ComponentName::Staking, 1)])
+    }
+
+    // Get the remainder of the issuance that couldn't be distributed in the previous epoch.
+    async fn remainder(&self) -> Result<u64> {
+        self.get_proto(state_key::remainder())
+            .await
+            .map(Option::unwrap_or_default)
+    }
+
+    // Set the remainder of the issuance that will be carried forward to the next epoch.
+    fn set_remainder(&mut self, remainder: u64) {
+        self.put_proto(state_key::remainder().to_string(), remainder)
+    }
+
+    // Get the total issuance of staking tokens for all time.
+    async fn total_issued(&self) -> Result<u64> {
+        self.get_proto(state_key::total_issued())
+            .await
+            .map(Option::unwrap_or_default)
+    }
+
+    // Set the total issuance of staking tokens for all time.
+    fn set_total_issued(&mut self, total_issued: u64) {
+        self.put_proto(state_key::total_issued().to_string(), total_issued)
     }
 }
+
+impl<S: StateRead + StateWrite> DistributionsImpl for S {}
diff --git a/crates/core/component/distributions/src/component/state_key.rs b/crates/core/component/distributions/src/component/state_key.rs
index 8b13789179..90cfe3402a 100644
--- a/crates/core/component/distributions/src/component/state_key.rs
+++ b/crates/core/component/distributions/src/component/state_key.rs
@@ -1 +1,9 @@
+// The remainder that has yet to be distributed
+pub fn remainder() -> &'static str {
+    "distributions/remainder"
+}
 
+// The cumulative total issuance
+pub fn total_issued() -> &'static str {
+    "distributions/total_issued"
+}
diff --git a/crates/core/component/shielded-pool/src/component/supply.rs b/crates/core/component/shielded-pool/src/component/supply.rs
index aacd3fec73..d75d47338f 100644
--- a/crates/core/component/shielded-pool/src/component/supply.rs
+++ b/crates/core/component/shielded-pool/src/component/supply.rs
@@ -62,37 +62,18 @@ pub trait SupplyWrite: StateWrite {
         let key = state_key::token_supply(asset_id);
         let current_supply: Amount = self.get_proto(&key).await?.unwrap_or(0u64).into();
 
-        // TODO: replace with a single checked_add_signed call when mixed_integer_ops lands in stable (1.66)
-        let new_supply: Amount = if change < 0 {
-            current_supply
-                .value()
-                .checked_sub(change.unsigned_abs())
-                .ok_or_else(|| {
-                    anyhow::anyhow!(
-                        "underflow updating token {} supply {} with delta {}",
-                        asset_id,
-                        current_supply,
-                        change
-                    )
-                })?
-                .into()
-        } else {
-            current_supply
-                .value()
-                .checked_add(change as u128)
-                .ok_or_else(|| {
-                    anyhow::anyhow!(
-                        "overflow updating token {} supply {} with delta {}",
-                        asset_id,
-                        current_supply,
-                        change
-                    )
-                })?
-                .into()
-        };
-        tracing::debug!(?current_supply, ?new_supply, ?change);
+        let new_supply = current_supply.checked_add_signed(change).ok_or_else(|| {
+            anyhow::anyhow!(
+                "over-/under-flow updating token {} supply {} with delta {}",
+                asset_id,
+                current_supply,
+                change
+            )
+        })?;
 
+        tracing::debug!(?current_supply, ?new_supply, ?change);
         self.put(key, new_supply);
+
         Ok(())
     }
 }
diff --git a/crates/core/component/shielded-pool/src/state_key.rs b/crates/core/component/shielded-pool/src/state_key.rs
index edbb8d6121..d49f6c1d99 100644
--- a/crates/core/component/shielded-pool/src/state_key.rs
+++ b/crates/core/component/shielded-pool/src/state_key.rs
@@ -6,6 +6,11 @@ pub fn token_supply(asset_id: &asset::Id) -> String {
     format!("shielded_pool/assets/{asset_id}/token_supply")
 }
 
+// The total supply of penumbra tokens in any form (unstaked, staked, or unbonding)
+pub fn staking_token_total_supply() -> &'static str {
+    "shielded_pool/staking_token_total_supply"
+}
+
 pub fn known_assets() -> &'static str {
     "shielded_pool/known_assets"
 }
diff --git a/crates/core/component/stake/src/action_handler/validator_definition.rs b/crates/core/component/stake/src/action_handler/validator_definition.rs
index d9982a9e17..75346176ff 100644
--- a/crates/core/component/stake/src/action_handler/validator_definition.rs
+++ b/crates/core/component/stake/src/action_handler/validator_definition.rs
@@ -117,15 +117,9 @@ impl ActionHandler for validator::Definition {
                 validator_reward_rate: 0,
                 validator_exchange_rate: 1_0000_0000, // 1 represented as 1e8
             };
-            let next_rate_data = RateData {
-                identity_key: validator_key,
-                epoch_index: cur_epoch.index + 1,
-                validator_reward_rate: 0,
-                validator_exchange_rate: 1_0000_0000, // 1 represented as 1e8
-            };
 
             state
-                .add_validator(v.validator.clone(), cur_rate_data, next_rate_data)
+                .add_validator(v.validator.clone(), cur_rate_data)
                 .await
                 .unwrap();
         }
diff --git a/crates/core/component/stake/src/component.rs b/crates/core/component/stake/src/component.rs
index daa7f64f6e..9ac9af7728 100644
--- a/crates/core/component/stake/src/component.rs
+++ b/crates/core/component/stake/src/component.rs
@@ -290,103 +290,93 @@ pub(crate) trait StakingImpl: StateWriteExt {
 
     #[instrument(skip(self, epoch_to_end), fields(index = epoch_to_end.index))]
     async fn end_epoch(&mut self, epoch_to_end: Epoch) -> Result<()> {
-        // calculate rate data for next rate, move previous next rate to cur rate,
-        // and save the next rate data. ensure that non-Active validators maintain constant rates.
-        let mut delegations_by_validator = BTreeMap::<IdentityKey, Vec<Delegate>>::new();
-        let mut undelegations_by_validator = BTreeMap::<IdentityKey, Vec<Undelegate>>::new();
-
-        let end_height = self.get_block_height().await?;
-
-        for height in epoch_to_end.start_height..=end_height {
-            let changes = self.delegation_changes(height.try_into().unwrap()).await?;
-            for d in changes.delegations {
-                delegations_by_validator
-                    .entry(d.validator_identity.clone())
-                    .or_insert_with(Vec::new)
-                    .push(d);
-            }
-            for u in changes.undelegations {
-                undelegations_by_validator
-                    .entry(u.validator_identity.clone())
-                    .or_insert_with(Vec::new)
-                    .push(u);
-            }
-        }
-        tracing::debug!(
-            total_delegations = ?delegations_by_validator.values().map(|v| v.len())
-                .sum::<usize>(),
-            total_undelegations = ?undelegations_by_validator.values().map(|v| v.len())
-                .sum::<usize>(),
-        );
-
-        let chain_params = self.get_chain_params().await?;
-
         tracing::debug!("processing base rate");
-        // We are transitioning to the next epoch, so set "cur_base_rate" to the previous "next_base_rate", and
-        // update "next_base_rate".
-        let current_base_rate = self.next_base_rate().await?;
-
-        let next_base_rate = current_base_rate.next(chain_params.base_reward_rate);
-
-        // rename to curr_rate so it lines up with next_rate (same # chars)
-        tracing::debug!(curr_base_rate = ?current_base_rate);
-        tracing::debug!(?next_base_rate);
-
-        // Update the base rates in the JMT:
-        self.set_base_rates(current_base_rate.clone(), next_base_rate.clone())
-            .await;
 
+        // Grab the validator list as a vector since we need to iterate over it twice
+        // TODO: this should return a stream and only be processed once, which is possible once we
+        // have an index for all active validators
         let validator_list = self.validator_list().await?;
+
+        // Process slashings
         for validator in &validator_list {
-            // The old epoch's "next rate" is now the "current rate"...
-            let old_next_rate = self
-                .next_validator_rate(&validator.identity_key)
+            // We consider ourselves to be "in between" epochs right now, so the current validator
+            // rate for the epoch we are ending is the "previous validator rate", while the rate we
+            // will calculate for the next epoch about to start is the "upcoming validator rate":
+            let previous_validator_rate_unslashed = self
+                .current_validator_rate(&validator.identity_key)
                 .await?
                 .ok_or_else(|| {
                     anyhow::anyhow!("validator had ID in validator_list but rate not found in JMT")
                 })?;
-            // ... as soon as we apply any penalties recorded in the previous epoch.
+
+            // The above validator rate has not yet had any accumulated slashing penalties applied,
+            // so we need to apply them now:
             let penalty = self
                 .penalty_in_epoch(&validator.identity_key, epoch_to_end.index)
                 .await?
                 .unwrap_or_default();
-            let current_rate = old_next_rate.slash(penalty);
 
-            let validator_state = self
-                .validator_state(&validator.identity_key)
-                .await?
-                .ok_or_else(|| {
-                    anyhow::anyhow!("validator had ID in validator_list but state not found in JMT")
-                })?;
-            tracing::debug!(?validator, "processing validator rate updates");
+            // The *actual* previous validator rate (as opposed to the merely anticipated one that
+            // was written early into the state) is that previous validator rate, minus the slashing
+            // penalties that it incurred in the previous epoch:
+            let previous_validator_rate = previous_validator_rate_unslashed.slash(penalty);
 
-            let funding_streams = validator.funding_streams.clone();
+            // Set the validator rate in the state to account for slashing penalties incurred in the
+            // preceding epoch
+            self.set_validator_rates(&validator.identity_key, previous_validator_rate);
+        }
 
-            let next_rate =
-                current_rate.next(&next_base_rate, funding_streams.as_ref(), &validator_state);
-            assert!(next_rate.epoch_index == epoch_to_end.index + 2);
+        // Total the delegations and undelegations for the epoch, for each validator
+        let mut total_delegations = 0;
+        let mut total_undelegations = 0;
+        let mut delegation_delta_by_validator = BTreeMap::<IdentityKey, i128>::new();
 
-            let total_delegations = delegations_by_validator
-                .get(&validator.identity_key)
-                .into_iter()
-                .flat_map(|ds| ds.iter().map(|d| d.delegation_amount.value()))
-                .sum::<u128>();
-            let total_undelegations = undelegations_by_validator
-                .get(&validator.identity_key)
-                .into_iter()
-                .flat_map(|us| us.iter().map(|u| u.delegation_amount.value()))
-                .sum::<u128>();
-            let delegation_delta = (total_delegations as i128) - (total_undelegations as i128);
+        let end_height = self.get_block_height().await?;
+        for height in epoch_to_end.start_height..=end_height {
+            let changes = self.delegation_changes(height.try_into().unwrap()).await?;
+            for d in changes.delegations {
+                let delta: i128 = d
+                    .delegation_amount
+                    .value()
+                    .try_into()
+                    .map_err(|_| anyhow::anyhow!("delegation amount larger than i128::MAX"))?;
+                *delegation_delta_by_validator
+                    .entry(d.validator_identity.clone())
+                    .or_insert(0) += delta;
+                total_delegations += 1;
+            }
+            for u in changes.undelegations {
+                let delta: i128 =
+                    u.delegation_amount.value().try_into().map_err(|_| {
+                        anyhow::anyhow!("undelegation amount larger than i128::MAX")
+                    })?;
+                *delegation_delta_by_validator
+                    .entry(u.validator_identity.clone())
+                    .or_insert(0) -= delta;
+                total_undelegations += 1;
+            }
+        }
+        tracing::debug!(total_delegations, total_undelegations);
 
+        // Adjust the token supply for each validator based on the delegation deltas
+        for (identity_key, delegation_delta) in delegation_delta_by_validator {
             tracing::debug!(
-                validator = ?validator.identity_key,
+                validator = ?identity_key,
                 total_delegations,
                 total_undelegations,
                 delegation_delta
             );
 
+            // Grab the previous validator rate, which has now had slashing applied to it
+            let previous_validator_rate = self
+                .current_validator_rate(&identity_key)
+                .await?
+                .ok_or_else(|| {
+                    anyhow::anyhow!("validator had ID in validator_list but rate not found in JMT")
+                })?;
+
             let abs_unbonded_amount =
-                current_rate.unbonded_amount(delegation_delta.unsigned_abs()) as i128;
+                previous_validator_rate.unbonded_amount(delegation_delta.unsigned_abs()) as i128;
             let staking_delta = if delegation_delta >= 0 {
                 // Net delegation: subtract the unbonded amount from the staking token supply
                 -abs_unbonded_amount
@@ -396,14 +386,102 @@ pub(crate) trait StakingImpl: StateWriteExt {
             };
 
             // update the delegation token supply in the JMT
-            self.update_token_supply(
-                &DelegationToken::from(validator.identity_key).id(),
-                delegation_delta,
-            )
-            .await?;
+            self.update_token_supply(&DelegationToken::from(identity_key).id(), delegation_delta)
+                .await?;
             // update the staking token supply in the JMT
             self.update_token_supply(&STAKING_TOKEN_ASSET_ID, staking_delta)
                 .await?;
+        }
+
+        // Find out how much stake is delegated to the active validator set only
+        let previous_total_active_stake = self.total_active_stake().await?;
+
+        // Ask the distributions component for the total issuance of the staking token to be
+        // distributed as staking rewards this epoch
+        let issuance = self.staking_issuance().await?;
+
+        // We consider ourselves to be "in between" epochs at this point: the current base rate of
+        // the epoch we are ending is the "previous base rate", while the base rate of the next
+        // epoch about to begin is the "upcoming base rate":
+        let previous_base_rate = self.current_base_rate().await?; // looking backwards, our current rate is the previous rate
+        const BPS_SQUARED: u64 = 1_0000_0000; // reward rate is measured in basis points squared
+        let upcoming_base_reward_rate = issuance * BPS_SQUARED / previous_total_active_stake;
+        let upcoming_base_rate = previous_base_rate.next(upcoming_base_reward_rate);
+
+        tracing::debug!(?previous_base_rate);
+        tracing::debug!(?upcoming_base_rate);
+
+        // Update the base rates in the JMT to the upcoming base rate.
+        self.set_base_rate(upcoming_base_rate.clone()).await;
+
+        // Update each validator's rate
+        for validator in &validator_list {
+            // Grab the previous validator rate, which has now had slashing applied to it
+            let previous_validator_rate = self
+                .current_validator_rate(&validator.identity_key)
+                .await?
+                .ok_or_else(|| {
+                    anyhow::anyhow!("validator had ID in validator_list but rate not found in JMT")
+                })?;
+
+            let validator_state = self
+                .validator_state(&validator.identity_key)
+                .await?
+                .ok_or_else(|| {
+                    anyhow::anyhow!("validator had ID in validator_list but state not found in JMT")
+                })?;
+
+            tracing::debug!(?validator, "processing validator rate updates");
+
+            // Based on the upcoming base rate, calculate this validator's upcoming rate
+            let upcoming_validator_rate = previous_validator_rate.next(
+                &upcoming_base_rate,
+                validator.funding_streams.as_ref(),
+                &validator_state,
+            );
+
+            // Update the state of the validator within the validator set
+            // with the newly starting epoch's calculated exchange rate.
+            self.set_validator_rates(&validator.identity_key, upcoming_validator_rate.clone());
+
+            tracing::debug!(validator = ?validator.identity_key, ?previous_validator_rate, ?upcoming_validator_rate);
+        }
+
+        // Loop over the active validators again to calculate the remainder of issuance that
+        // couldn't be assigned due to precision loss, and write it back to the state
+        let upcoming_total_active_stake = self.total_active_stake().await?;
+        tracing::debug!(?previous_total_active_stake, ?upcoming_total_active_stake);
+
+        // Calculate the remainder of issuance that couldn't be assigned due to precision loss, and
+        // set it as the next epoch's staking issuance. The distributions module will take this as
+        // an input to determine the next epoch's staking rewards.
+        let unissued = issuance
+            .checked_sub(upcoming_total_active_stake.checked_sub(previous_total_active_stake).ok_or_else(|| {
+                anyhow::anyhow!(
+                    "upcoming total active stake ({}) is less than previous total active stake ({})",
+                    upcoming_total_active_stake,
+                    previous_total_active_stake
+                )
+            })?)
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "actual issuance ({}) is greater than input issuance ({})",
+                    upcoming_total_active_stake,
+                    issuance
+                )
+            })?;
+        tracing::debug!(?unissued);
+        self.set_staking_issuance(unissued);
+
+        // Update each validator's voting power
+        for validator in &validator_list {
+            // We have now set the rate, so we can calculate the voting power based on the new rate
+            let upcoming_validator_rate = self
+                .current_validator_rate(&validator.identity_key)
+                .await?
+                .ok_or_else(|| {
+                    anyhow::anyhow!("validator had ID in validator_list but rate not found in JMT")
+                })?;
 
             let delegation_token_supply = self
                 .token_supply(&DelegationToken::from(validator.identity_key).id())
@@ -411,31 +489,41 @@ pub(crate) trait StakingImpl: StateWriteExt {
                 .expect("delegation token should be known");
 
             // Calculate the voting power in the newly beginning epoch
-            let voting_power =
-                current_rate.voting_power(delegation_token_supply.into(), &current_base_rate);
-            tracing::debug!(?voting_power);
+            let upcoming_voting_power = upcoming_validator_rate
+                .voting_power(delegation_token_supply.into(), &upcoming_base_rate);
+            tracing::debug!(?upcoming_voting_power);
 
-            // Update the state of the validator within the validator set
-            // with the newly starting epoch's calculated voting rate and power.
-            self.set_validator_rates(
-                &validator.identity_key,
-                current_rate.clone(),
-                next_rate.clone(),
-            );
-            self.set_validator_power(&validator.identity_key, voting_power)
+            // Update the validator's voting power
+            self.set_validator_power(&validator.identity_key, upcoming_voting_power)
                 .await?;
+        }
+
+        // Distribute staking rewards
+        for validator in &validator_list {
+            let delegation_token_supply = self
+                .token_supply(&DelegationToken::from(validator.identity_key).id())
+                .await?
+                .expect("delegation token should be known");
+
+            let validator_state = self
+                .validator_state(&validator.identity_key)
+                .await?
+                .ok_or_else(|| {
+                    anyhow::anyhow!("validator had ID in validator_list but state not found in JMT")
+                })?;
 
             // Only Active validators produce commission rewards
             // The validator *may* drop out of Active state during the next epoch,
             // but the commission rewards for the ending epoch in which it was Active
             // should still be rewarded.
+            // TODO: refactor this to be a loop only over active validators
             if validator_state == validator::State::Active {
                 // distribute validator commission
-                for stream in funding_streams {
+                for stream in validator.funding_streams.as_ref() {
                     let commission_reward_amount = stream.reward_amount(
                         delegation_token_supply,
-                        &next_base_rate,
-                        &current_base_rate,
+                        &upcoming_base_rate,
+                        &previous_base_rate,
                     );
 
                     match stream.recipient() {
@@ -465,13 +553,8 @@ pub(crate) trait StakingImpl: StateWriteExt {
                 }
             }
 
-            // rename to curr_rate so it lines up with next_rate (same # chars)
             let delegation_denom = DelegationToken::from(&validator.identity_key).denom();
-            tracing::debug!(curr_rate = ?current_rate);
-            tracing::debug!(?next_rate);
-            tracing::debug!(?delegation_delta);
-            tracing::debug!(?delegation_token_supply);
-            tracing::debug!(?delegation_denom);
+            tracing::debug!(validator = ?validator.identity_key, ?delegation_token_supply, ?delegation_denom);
         }
 
         // Now that all the voting power has been calculated for the upcoming epoch,
@@ -479,10 +562,6 @@ pub(crate) trait StakingImpl: StateWriteExt {
         self.process_validator_unbondings().await?;
         self.set_active_and_inactive_validators().await?;
 
-        // The pending delegation changes should be empty at the beginning of the next epoch.
-        // TODO: check that this was a no-op
-        // self.delegation_changes = Default::default();
-
         Ok(())
     }
 
@@ -745,12 +824,6 @@ pub(crate) trait StakingImpl: StateWriteExt {
             validator_reward_rate: 0,
             validator_exchange_rate: 1_0000_0000, // 1 represented as 1e8
         };
-        let next_rate_data = RateData {
-            identity_key: validator.identity_key.clone(),
-            epoch_index: genesis_base_rate.epoch_index + 1,
-            validator_reward_rate: 0,
-            validator_exchange_rate: 1_0000_0000, // 1 represented as 1e8
-        };
 
         // The initial allocations to the validator are specified in `genesis_allocations`.
         // We use these to determine the initial voting power for each validator.
@@ -766,7 +839,6 @@ pub(crate) trait StakingImpl: StateWriteExt {
         self.add_validator_inner(
             validator.clone(),
             cur_rate_data,
-            next_rate_data,
             // All genesis validators start in the "Active" state:
             validator::State::Active,
             // All genesis validators start in the "Bonded" bonding state:
@@ -788,19 +860,13 @@ pub(crate) trait StakingImpl: StateWriteExt {
 
     /// Add a validator after genesis, which will start in Inactive
     /// state with no power assigned.
-    async fn add_validator(
-        &mut self,
-        validator: Validator,
-        cur_rate_data: RateData,
-        next_rate_data: RateData,
-    ) -> Result<()> {
+    async fn add_validator(&mut self, validator: Validator, cur_rate_data: RateData) -> Result<()> {
         // We explicitly do not call `update_tm_validator_power` here,
         // as a post-genesis validator should not have power reported
         // to Tendermint until it becomes Active.
         self.add_validator_inner(
             validator.clone(),
             cur_rate_data,
-            next_rate_data,
             // All post-genesis validators start in the "Inactive" state:
             validator::State::Inactive,
             // And post-genesis validators have "Unbonded" bonding state:
@@ -887,14 +953,7 @@ impl Component for Staking {
             base_reward_rate: 0,
             base_exchange_rate: 1_0000_0000,
         };
-        let next_base_rate = BaseRateData {
-            epoch_index: epoch_index + 1,
-            base_reward_rate: 0,
-            base_exchange_rate: 1_0000_0000,
-        };
-        state
-            .set_base_rates(genesis_base_rate.clone(), next_base_rate)
-            .await;
+        state.set_base_rate(genesis_base_rate.clone()).await;
 
         // Compile totals of genesis allocations by denom, which we can use
         // to compute the delegation tokens for each validator.
@@ -988,6 +1047,13 @@ pub trait StateReadExt: StateRead {
             .unwrap_or_default()
     }
 
+    /// Gets the staking issuance for this epoch.
+    async fn staking_issuance(&self) -> Result<u64> {
+        self.get_proto(&state_key::current_staking_issuance())
+            .await
+            .map(Option::unwrap_or_default)
+    }
+
     async fn penalty_in_epoch(
         &self,
         id: &IdentityKey,
@@ -1027,12 +1093,6 @@ pub trait StateReadExt: StateRead {
             .map(|rate_data| rate_data.expect("rate data must be set after init_chain"))
     }
 
-    async fn next_base_rate(&self) -> Result<BaseRateData> {
-        self.get(state_key::next_base_rate())
-            .await
-            .map(|rate_data| rate_data.expect("rate data must be set after init_chain"))
-    }
-
     fn current_validator_rate(
         &self,
         identity_key: &IdentityKey,
@@ -1041,11 +1101,6 @@ pub trait StateReadExt: StateRead {
             .boxed()
     }
 
-    async fn next_validator_rate(&self, identity_key: &IdentityKey) -> Result<Option<RateData>> {
-        self.get(&state_key::next_rate_by_validator(identity_key))
-            .await
-    }
-
     fn validator_power(&self, identity_key: &IdentityKey) -> ProtoFuture<u64, Self::GetRawFut> {
         self.get_proto(&state_key::power_by_validator(identity_key))
     }
@@ -1103,7 +1158,7 @@ pub trait StateReadExt: StateRead {
     async fn validator_info(&self, identity_key: &IdentityKey) -> Result<Option<validator::Info>> {
         let validator = self.validator(identity_key).await?;
         let status = self.validator_status(identity_key).await?;
-        let rate_data = self.next_validator_rate(identity_key).await?;
+        let rate_data = self.current_validator_rate(identity_key).await?;
         match (validator, status, rate_data) {
             (Some(validator), Some(status), Some(rate_data)) => Ok(Some(validator::Info {
                 validator,
@@ -1153,6 +1208,7 @@ pub trait StateReadExt: StateRead {
         &self,
     ) -> Pin<Box<dyn Future<Output = Result<Vec<IdentityKey>>> + Send + 'static>> {
         let mut iks = Vec::new();
+        //
         // TODO: boxing here is to avoid an Unpin problem.. should
         // we bound the StateRead stream GATs as Unpin?
         // TODO: why did the previous implementation of this method
@@ -1238,6 +1294,53 @@ pub trait StateReadExt: StateRead {
 
         Ok(std::cmp::min(default_unbonding, validator_unbonding))
     }
+
+    /// Calculate the amount of stake that is delegated to the currently active validator set,
+    /// denominated in the staking token.
+    #[instrument(skip(self))]
+    async fn total_active_stake(&self) -> Result<u64> {
+        let validator_list = self.validator_identity_list().await?;
+
+        let mut total_active_stake: u64 = 0;
+        for validator in &validator_list {
+            // Filter the list for active validators only
+            // TODO: use an index so we don't have to iterate over the whole list
+            let validator_state = self.validator_state(validator).await?.ok_or_else(|| {
+                anyhow::anyhow!("validator had ID in validator_list but state not found in JMT")
+            })?;
+            if validator_state != validator::State::Active {
+                continue;
+            }
+
+            let delegation_token_supply = self
+                .token_supply(&DelegationToken::from(validator).id())
+                .await?
+                .expect("delegation token should be known");
+
+            let validator_rate =
+                self.current_validator_rate(validator)
+                    .await?
+                    .ok_or_else(|| {
+                        anyhow::anyhow!(
+                            "validator had ID in validator_list but rate not found in JMT"
+                        )
+                    })?;
+
+            // Add the validator's unbonded amount to the total active stake
+            total_active_stake = total_active_stake
+                .checked_add(
+                    validator_rate
+                        .unbonded_amount(delegation_token_supply.into())
+                        .try_into()
+                        .map_err(|_| {
+                            anyhow::anyhow!("validator rate unbonded amount overflowed u64")
+                        })?,
+                )
+                .ok_or_else(|| anyhow::anyhow!("total active stake overflowed u64"))?;
+        }
+
+        Ok(total_active_stake)
+    }
 }
 
 impl<T: StateRead + ?Sized> StateReadExt for T {}
@@ -1267,11 +1370,16 @@ pub trait StateWriteExt: StateWrite {
         self.put_stub_delegation_changes(changes);
     }
 
+    /// Sets the staking issuance for the next epoch (which may be modified by the distributions
+    /// module before being consumed later).
+    fn set_staking_issuance(&mut self, issuance: u64) {
+        self.put_proto(state_key::current_staking_issuance().to_string(), issuance)
+    }
+
     #[instrument(skip(self))]
-    async fn set_base_rates(&mut self, current: BaseRateData, next: BaseRateData) {
+    async fn set_base_rate(&mut self, current: BaseRateData) {
         tracing::debug!("setting base rates");
         self.put(state_key::current_base_rate().to_owned(), current);
-        self.put(state_key::next_base_rate().to_owned(), next);
     }
 
     #[instrument(skip(self))]
@@ -1291,18 +1399,12 @@ pub trait StateWriteExt: StateWrite {
     }
 
     #[instrument(skip(self))]
-    fn set_validator_rates(
-        &mut self,
-        identity_key: &IdentityKey,
-        current_rates: RateData,
-        next_rates: RateData,
-    ) {
+    fn set_validator_rates(&mut self, identity_key: &IdentityKey, current_rates: RateData) {
         tracing::debug!("setting validator rates");
         self.put(
             state_key::current_rate_by_validator(identity_key),
             current_rates,
         );
-        self.put(state_key::next_rate_by_validator(identity_key), next_rates);
     }
 
     async fn register_consensus_key(
@@ -1351,7 +1453,6 @@ pub trait StateWriteExt: StateWrite {
         &mut self,
         validator: Validator,
         current_rates: RateData,
-        next_rates: RateData,
         state: validator::State,
         bonding_state: validator::BondingState,
         power: u64,
@@ -1365,7 +1466,7 @@ pub trait StateWriteExt: StateWrite {
         self.register_denom(&DelegationToken::from(&id).denom())
             .await?;
 
-        self.set_validator_rates(&id, current_rates, next_rates);
+        self.set_validator_rates(&id, current_rates);
 
         // We can't call `set_validator_state` here because it requires an existing validator state,
         // so we manually initialize the state for new validators.
diff --git a/crates/core/component/stake/src/identity_key.rs b/crates/core/component/stake/src/identity_key.rs
index a62fc5a84f..2530c2d885 100644
--- a/crates/core/component/stake/src/identity_key.rs
+++ b/crates/core/component/stake/src/identity_key.rs
@@ -1,5 +1,5 @@
 use penumbra_proto::{
-    client::v1alpha1::{CurrentValidatorRateRequest, NextValidatorRateRequest},
+    client::v1alpha1::CurrentValidatorRateRequest,
     core::crypto::v1alpha1 as pb,
     serializers::bech32str::{self, validator_identity_key::BECH32_PREFIX},
     DomainType, TypeUrl,
@@ -70,25 +70,6 @@ impl TryFrom<pb::IdentityKey> for IdentityKey {
     }
 }
 
-impl From<IdentityKey> for NextValidatorRateRequest {
-    fn from(k: IdentityKey) -> Self {
-        NextValidatorRateRequest {
-            identity_key: Some(k.into()),
-            chain_id: Default::default(),
-        }
-    }
-}
-
-impl TryFrom<NextValidatorRateRequest> for IdentityKey {
-    type Error = anyhow::Error;
-    fn try_from(value: NextValidatorRateRequest) -> Result<Self, Self::Error> {
-        value
-            .identity_key
-            .ok_or_else(|| anyhow::anyhow!("empty NextValidatorRateRequest message"))?
-            .try_into()
-    }
-}
-
 impl From<IdentityKey> for CurrentValidatorRateRequest {
     fn from(k: IdentityKey) -> Self {
         CurrentValidatorRateRequest {
diff --git a/crates/core/component/stake/src/rate.rs b/crates/core/component/stake/src/rate.rs
index 2a3f429459..59b7ded6e6 100644
--- a/crates/core/component/stake/src/rate.rs
+++ b/crates/core/component/stake/src/rate.rs
@@ -2,9 +2,7 @@
 
 use penumbra_num::Amount;
 use penumbra_proto::client::v1alpha1::CurrentValidatorRateResponse;
-use penumbra_proto::{
-    client::v1alpha1::NextValidatorRateResponse, core::stake::v1alpha1 as pb, DomainType, TypeUrl,
-};
+use penumbra_proto::{core::stake::v1alpha1 as pb, DomainType, TypeUrl};
 use serde::{Deserialize, Serialize};
 
 use crate::{validator::State, FundingStream, IdentityKey};
@@ -255,25 +253,6 @@ impl TryFrom<pb::BaseRateData> for BaseRateData {
     }
 }
 
-impl From<RateData> for NextValidatorRateResponse {
-    fn from(r: RateData) -> Self {
-        NextValidatorRateResponse {
-            data: Some(r.into()),
-        }
-    }
-}
-
-impl TryFrom<NextValidatorRateResponse> for RateData {
-    type Error = anyhow::Error;
-
-    fn try_from(value: NextValidatorRateResponse) -> Result<Self, Self::Error> {
-        value
-            .data
-            .ok_or_else(|| anyhow::anyhow!("empty NextValidatorRateResponse message"))?
-            .try_into()
-    }
-}
-
 impl From<RateData> for CurrentValidatorRateResponse {
     fn from(r: RateData) -> Self {
         CurrentValidatorRateResponse {
diff --git a/crates/core/component/stake/src/state_key.rs b/crates/core/component/stake/src/state_key.rs
index c46f7d76af..473a3afe7a 100644
--- a/crates/core/component/stake/src/state_key.rs
+++ b/crates/core/component/stake/src/state_key.rs
@@ -7,8 +7,8 @@ pub fn current_base_rate() -> &'static str {
     "staking/base_rate/current"
 }
 
-pub fn next_base_rate() -> &'static str {
-    "staking/base_rate/next"
+pub fn current_staking_issuance() -> &'static str {
+    "staking/issuance/current"
 }
 
 pub mod validators {
@@ -42,10 +42,6 @@ pub fn current_rate_by_validator(id: &IdentityKey) -> String {
     format!("staking/validator_rate/current/{id}")
 }
 
-pub fn next_rate_by_validator(id: &IdentityKey) -> String {
-    format!("staking/validator_rate/next/{id}")
-}
-
 pub fn power_by_validator(id: &IdentityKey) -> String {
     format!("staking/validator_power/{id}")
 }
diff --git a/crates/core/num/src/allocate.rs b/crates/core/num/src/allocate.rs
new file mode 100644
index 0000000000..0ae5179101
--- /dev/null
+++ b/crates/core/num/src/allocate.rs
@@ -0,0 +1,266 @@
+use crate::fixpoint::U128x128;
+
+/// Compute an exact integer allocation of `total_allocation` units, proportioned according to the
+/// given `weights`, minimizing the average error ratio per key.
+///
+/// The maximum error in the allocation for any key is 1 unit; that is, a perfect fractional
+/// allocation would differ for each key by no more than 1.
+///
+/// This function is guaranteed to return an allocation unless it is impossible to do so: the only
+/// corner case where this is impossible is when the total allocation is non-zero and the sum of the
+/// weights is zero. Any time outside this condition, an allocation is returned, and it is
+/// guaranteed to be exact: the sum of the allocations returned will be exactly the requested total
+/// allocation.
+///
+/// The allocation returned is guaranteed to be deterministic regardless of the initial order of the
+/// weights: ties are broken by preferring keys with an earlier ordering. If multiple equal keys are
+/// present, they are treated as separate and their weights are not combined, with preference being
+/// given to the key which appears earliest in the list of weights.
+///
+/// The ordering of the keys in the returned allocation will be lexicographic by (weight, key), even
+/// if the allocations given to a particular two keys end up being equal. This means that you
+/// *cannot* rely on the ordering placing earlier-ordered keys first, even if their allocations are
+/// the same. If you want to ensure a particular ordering, you must sort the keys yourself afterwards.
+pub fn allocate<K: Ord>(
+    mut total_allocation: u128,
+    mut weights: Vec<(K, u128)>,
+) -> Option<Vec<(K, u128)>> {
+    // If the total allocation is zero, then every key will be allocated zero, so we can forget all
+    // the weights without doing any more processing of them.
+    if total_allocation == 0 {
+        weights.clear();
+    }
+
+    // Scale the weights down to fit in a `u128`.
+    let mut total_weight = scale_to_u128(&mut weights);
+
+    // If the total weight is zero, then we can't allocate anything, which would violate the
+    // guarantee to allocate exactly if we returned any result.
+    if total_weight == 0 && total_allocation != 0 {
+        return None;
+    }
+
+    // Sorting the keys by ascending weight minimizes the *percentage* error in the allocations,
+    // because as the total remaining allocation decreases, the amount of error in a rounding
+    // division increases, but since we are ascending the weights, we're pushing higher error
+    // (which, notably, is capped at 1 unit of allocation, maximum!) to the most-weighted keys,
+    // which means that the average *percentage* error is minimized, since the total allocation to
+    // the most-weighted keys is the highest, and therefore the absolute error matters least to
+    // them.
+    weights.sort_by(|(key_a, weight_a), (key_b, weight_b)| {
+        // Sort by weight, then by key to break ties.
+        weight_a.cmp(weight_b).then(key_a.cmp(key_b))
+    });
+
+    // For each key in the weights, calculate the allocation for that key, sequentially iterating
+    // from least-weighted to most-weighted.
+    //
+    // If two keys are equally-weighted, then it could happen that one key gets 1 unit of allocation
+    // more than the other: this is deterministic based on comparing the keys, since above we sort
+    // the weights in ascending lexicographic order of (weight, key).
+    //
+    // This computation is done in-place on the weights vector, so that we can avoid allocating a
+    // new vector at any point during the whole procedure.
+    //
+    // This approach is loosely based off https://stackoverflow.com/a/38905829.
+    weights.retain_mut(move |(_, value)| {
+        // The weight is the current value at the key; we're going to replace it in-place with the
+        // allocation.
+        let weight = *value;
+        // The allocation for this key is the total allocation times the fraction of the
+        // total weight that this key has, rounded to the nearest integer.
+        let fraction_of_total_weight =
+            U128x128::ratio(weight, total_weight).expect("total weight is not zero");
+        let fractional_allocation = U128x128::from(total_allocation) * fraction_of_total_weight;
+        let integral_allocation = fractional_allocation
+            .expect("fraction of total weight is never greater than one")
+            .round_nearest() // must round to *nearest* to minimize error
+            .try_into()
+            .expect("rounded amount is always integral");
+        // We've assigned this weight, so subtract it from the remaining total.
+        total_weight -= weight;
+        // We've assigned this integral allocation, so subtract it from the remaining total.
+        total_allocation -= integral_allocation;
+        // Replace the value with its allocation.
+        *value = integral_allocation;
+        // Only keep this key if it was allocated something.
+        integral_allocation != 0
+    });
+    Some(weights)
+}
+
+/// Given an association of keys to weights, sum the weights, scaling down the weights uniformly to
+/// make sure that the total weight fits in a `u128`, returning the total and modifying the weights
+/// in-place.
+///
+/// This is used internally in [`exact_allocation`].
+pub fn scale_to_u128<K>(weights: &mut Vec<(K, u128)>) -> u128 {
+    // Calculate the total weight, tracking overflows so we can compute a scaling factor in the case
+    // when the total of weights exceeds `u128::MAX`. This is computing the sum as a `u256` in two
+    // limbs of `u128`: hi and lo.
+    let mut lo: u128 = 0;
+    let mut hi: u128 = 0;
+    for (_, weight) in weights.iter() {
+        if let Some(new_lo) = lo.checked_add(*weight) {
+            lo = new_lo;
+        } else {
+            // If lo overflows, track the overflow in hi.
+            hi += 1;
+            // Explicitly wrapping-add the weight to lo, so that we can continue without losing the remainder.
+            lo = lo.wrapping_add(*weight);
+        };
+    }
+
+    // Compute a scaling factor such that the total weight is scaled down to fit in a `u128` if this
+    // scaling factor is applied to each weight.
+    let scaling_factor = if hi == 0 {
+        // If there were no overflows, then the scaling factor is 1. This special case is desirable
+        // so that we get *zero* precision loss for weights that fit in a `u128`, rather than
+        // round-down loss from dividing by a computed scaling factor.
+        U128x128::from(1u8)
+    } else {
+        // If there were overflows, then the scaling factor is (hi . lo) as a U128x128. This is done
+        // so that if the total weight exceeds `u128::MAX`, we scale down the weights to fit within
+        // that bound: i.e., the hi limb of the total weight is the integral part of the scaling
+        // factor, since it represents by how many times we have exceeded `u128::MAX`.
+        U128x128::from_parts(hi, lo)
+    };
+
+    // Compute a new set of weights and total weight by applying the scaling factor to the weights.
+    // Even if there was overflow, the new total weight may be less than `u128::MAX`, since loss of
+    // precision when dividing individual weights may have reduced the total weight. This is done
+    // in-place using `Vec::retain` to avoid allocating a new vector.
+    let mut total_scaled_weight: u128 = 0;
+    weights.retain_mut(|(_, weight)| {
+        // Scale each weight down by dividing it by the scaling factor and rounding down.
+        *weight = (U128x128::from(*weight) / scaling_factor)
+            .expect("scaling factor is never zero")
+            .round_down() // must round *down* to avoid total exceeding `u128::MAX` in all situations
+            .try_into()
+            .expect("rounded amount is always integral");
+        // Track the total scaled weight, so we can return it.
+        total_scaled_weight += *weight;
+        // Only output the scaled weight if it is greater than zero, since we don't want to do extra
+        // work for weights that are dropped by scaling.
+        *weight != 0
+    });
+
+    total_scaled_weight
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn total_and_scale_to_u128_is_exact(
+            mut weights in proptest::collection::vec((0..u8::MAX, 0..u128::MAX), 0..(u8::MAX as usize))
+        ) {
+            let total_weight = scale_to_u128(&mut weights);
+
+            // The total weight is the sum of the scaled weights (implicit in this is that the sum
+            // of scaled weights doesn't overflow, which will panic the test).
+            let actual_total_weight: u128 = weights.iter().map(|(_, weight)| *weight).sum();
+            prop_assert_eq!(total_weight, actual_total_weight, "total weight is not exact");
+        }
+
+        #[test]
+        fn exact_allocation_is_exact(
+            total_allocation in 0u128..u128::MAX,
+            weights in proptest::collection::vec((0..u8::MAX, 0..u128::MAX), 0..(u8::MAX as usize))
+        ) {
+            let total_weight_is_zero = weights.iter().all(|(_, weight)| *weight == 0);
+            let allocation = allocate(total_allocation, weights.clone());
+
+            // If an allocation was returned, it is exact, and the total weight must have been
+            // nonzero; otherwise, the total weight must have been zero.
+            if let Some(allocation) = allocation {
+                // If an allocation was returned, then the total allocation is exactly the requested amount.
+                let actual_total_allocation: u128 = allocation.iter().map(|(_, allocation)| allocation).sum();
+                prop_assert_eq!(total_allocation, actual_total_allocation, "total allocation is not exact");
+                // And the total weight was not zero.
+                prop_assert!(!total_weight_is_zero, "total weight is zero when allocation returned");
+            } else {
+                // Otherwise, the total weight was zero.
+                prop_assert!(total_weight_is_zero, "total weight is not zero when no allocation returned");
+            }
+        }
+    }
+
+    #[test]
+    fn exact_allocation_simple() {
+        fn alloc<const N: usize>(n: u128, ws: [(&str, u128); N]) -> Option<Vec<(&str, u128)>> {
+            allocate(n, ws.to_vec())
+        }
+
+        assert_eq!(None, alloc(1, []), "can't allocate something to nobody");
+        assert_eq!(
+            None,
+            alloc(1, [("a", 0)]),
+            "can't allocate something to zero weights"
+        );
+        assert_eq!(Some(vec![]), alloc(0, []), "can allocate nothing to nobody");
+        assert_eq!(
+            Some(vec![]),
+            alloc(0, [("a", 1)]),
+            "can allocate nothing to somebody"
+        );
+        assert_eq!(
+            Some(vec![]),
+            alloc(0, [("a", 0)]),
+            "can allocate nothing to zero weights"
+        );
+        assert_eq!(
+            Some(vec![("a", 1)]),
+            alloc(1, [("a", 1)]),
+            "can allocate the whole pot to one person"
+        );
+        assert_eq!(
+            Some(vec![("a", 1)]),
+            alloc(1, [("a", 2)]),
+            "doubling the weight doesn't change the allocation"
+        );
+        assert_eq!(
+            Some(vec![("a", 1), ("b", 1)]),
+            alloc(2, [("a", 1), ("b", 1)]),
+            "can allocate the whole pot to two people exactly evenly"
+        );
+        assert_eq!(
+            Some(vec![("a", 1), ("b", 1)]),
+            alloc(2, [("a", 2), ("b", 2)]),
+            "doubling the weight doesn't change the allocation for two people"
+        );
+        assert_eq!(
+            Some(vec![("a", 1), ("b", 1)]),
+            alloc(2, [("a", 1), ("b", 2)]),
+            "allocating two units to two people with different weights"
+        );
+        assert_eq!(
+            Some(vec![("b", 1), ("a", 1)]),
+            alloc(2, [("a", 2), ("b", 1)]),
+            "allocating two units to two people with different weights, reverse order"
+        );
+        assert_eq!(
+            Some(vec![("a", 1), ("b", 1)]),
+            alloc(2, [("a", 1), ("b", 1), ("c", 1)]),
+            "can't allocate 2 units 3 people exactly evenly, so pick the first two"
+        );
+        assert_eq!(
+            Some(vec![("a", 1),/*       */("c", 1)]),
+            alloc(2, [("a", 1), ("b", 1), ("c", 2)]),
+            "can't allocate 2 units 3 people exactly evenly, so pick the first low-weight and the first high-weight"
+        );
+        assert_eq!(
+            Some(vec![/*     */ ("c", 1), ("b", 2)]),
+            alloc(3, [("a", 1), ("b", 3), ("c", 2)]),
+            "allocating 3 units to 3 people with different weights"
+        );
+        assert_eq!(
+            Some(vec![("b", 1), /*   */ ("a", 2)]),
+            alloc(3, [("a", u128::MAX), ("b", u128::MAX / 2)]),
+            "can allocate exactly even when the total weight is greater than u128::MAX"
+        );
+    }
+}
diff --git a/crates/core/num/src/amount.rs b/crates/core/num/src/amount.rs
index 9c16ec67f9..d747920a03 100644
--- a/crates/core/num/src/amount.rs
+++ b/crates/core/num/src/amount.rs
@@ -57,6 +57,12 @@ impl Amount {
             .map(|inner| Self { inner })
     }
 
+    pub fn checked_add_signed(&self, rhs: i128) -> Option<Self> {
+        Some(Amount {
+            inner: self.inner.checked_add_signed(rhs)?,
+        })
+    }
+
     pub fn saturating_add(&self, rhs: &Self) -> Self {
         Self {
             inner: self.inner.saturating_add(rhs.inner),
diff --git a/crates/core/num/src/fixpoint.rs b/crates/core/num/src/fixpoint.rs
index 7492866fd9..78d987d960 100644
--- a/crates/core/num/src/fixpoint.rs
+++ b/crates/core/num/src/fixpoint.rs
@@ -86,6 +86,11 @@ impl U128x128 {
         Self(U256::from_words(hi, lo))
     }
 
+    /// Construct this number from integral and fractional parts.
+    pub fn from_parts(integral: u128, fractional: u128) -> Self {
+        Self(U256::from_words(integral, fractional))
+    }
+
     pub fn ratio<T: Into<Self>>(numerator: T, denominator: T) -> Result<Self, Error> {
         numerator.into() / denominator.into()
     }
@@ -112,6 +117,19 @@ impl U128x128 {
         }
     }
 
+    /// Rounds the number to the nearest integer.
+    ///
+    /// If the fractional part is exactly 0.5, then this rounds up.
+    pub fn round_nearest(&self) -> Self {
+        let (_, fractional) = self.0.into_words();
+        let half = 1u128 << 127;
+        if fractional < half {
+            self.round_down()
+        } else {
+            self.round_up()
+        }
+    }
+
     /// Performs checked multiplication, returning `Ok` if no overflow occurred.
     pub fn checked_mul(self, rhs: &Self) -> Result<Self, Error> {
         // It's important to use `into_words` because the `U256` type has an
@@ -226,10 +244,10 @@ impl AllocVar<U128x128, Fq> for U128x128Var {
             .collect::<Vec<_>>();
 
         hi_128_var.enforce_equal(&Boolean::<Fq>::le_bits_to_fp_var(
-            &(&hi_128_bits[..]).to_bits_le()?,
+            &(hi_128_bits[..]).to_bits_le()?,
         )?)?;
         lo_128_var.enforce_equal(&Boolean::<Fq>::le_bits_to_fp_var(
-            &(&lo_128_bits[..]).to_bits_le()?,
+            &(lo_128_bits[..]).to_bits_le()?,
         )?)?;
 
         Ok(Self {
diff --git a/crates/core/num/src/lib.rs b/crates/core/num/src/lib.rs
index e3d487ab96..b29adda88f 100644
--- a/crates/core/num/src/lib.rs
+++ b/crates/core/num/src/lib.rs
@@ -1,4 +1,6 @@
+mod allocate;
 mod amount;
 pub mod fixpoint;
 
+pub use allocate::allocate;
 pub use amount::{Amount, AmountVar};
diff --git a/crates/proto/src/gen/penumbra.client.v1alpha1.rs b/crates/proto/src/gen/penumbra.client.v1alpha1.rs
index 8fca762b5a..df463b9010 100644
--- a/crates/proto/src/gen/penumbra.client.v1alpha1.rs
+++ b/crates/proto/src/gen/penumbra.client.v1alpha1.rs
@@ -185,23 +185,6 @@ pub struct CurrentValidatorRateResponse {
     #[prost(message, optional, tag = "1")]
     pub data: ::core::option::Option<super::super::core::stake::v1alpha1::RateData>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct NextValidatorRateRequest {
-    /// The expected chain id (empty string if no expectation).
-    #[prost(string, tag = "1")]
-    pub chain_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "2")]
-    pub identity_key: ::core::option::Option<
-        super::super::core::crypto::v1alpha1::IdentityKey,
-    >,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct NextValidatorRateResponse {
-    #[prost(message, optional, tag = "1")]
-    pub data: ::core::option::Option<super::super::core::stake::v1alpha1::RateData>,
-}
 /// Requests batch swap data associated with a given height and trading pair from the view service.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -1087,25 +1070,6 @@ pub mod specific_query_service_client {
             );
             self.inner.unary(request.into_request(), path, codec).await
         }
-        pub async fn next_validator_rate(
-            &mut self,
-            request: impl tonic::IntoRequest<super::NextValidatorRateRequest>,
-        ) -> Result<tonic::Response<super::NextValidatorRateResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/penumbra.client.v1alpha1.SpecificQueryService/NextValidatorRate",
-            );
-            self.inner.unary(request.into_request(), path, codec).await
-        }
         pub async fn current_validator_rate(
             &mut self,
             request: impl tonic::IntoRequest<super::CurrentValidatorRateRequest>,
@@ -2038,10 +2002,6 @@ pub mod specific_query_service_server {
             &self,
             request: tonic::Request<super::ValidatorPenaltyRequest>,
         ) -> Result<tonic::Response<super::ValidatorPenaltyResponse>, tonic::Status>;
-        async fn next_validator_rate(
-            &self,
-            request: tonic::Request<super::NextValidatorRateRequest>,
-        ) -> Result<tonic::Response<super::NextValidatorRateResponse>, tonic::Status>;
         async fn current_validator_rate(
             &self,
             request: tonic::Request<super::CurrentValidatorRateRequest>,
@@ -2355,46 +2315,6 @@ pub mod specific_query_service_server {
                     };
                     Box::pin(fut)
                 }
-                "/penumbra.client.v1alpha1.SpecificQueryService/NextValidatorRate" => {
-                    #[allow(non_camel_case_types)]
-                    struct NextValidatorRateSvc<T: SpecificQueryService>(pub Arc<T>);
-                    impl<
-                        T: SpecificQueryService,
-                    > tonic::server::UnaryService<super::NextValidatorRateRequest>
-                    for NextValidatorRateSvc<T> {
-                        type Response = super::NextValidatorRateResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::NextValidatorRateRequest>,
-                        ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move {
-                                (*inner).next_validator_rate(request).await
-                            };
-                            Box::pin(fut)
-                        }
-                    }
-                    let accept_compression_encodings = self.accept_compression_encodings;
-                    let send_compression_encodings = self.send_compression_encodings;
-                    let inner = self.inner.clone();
-                    let fut = async move {
-                        let inner = inner.0;
-                        let method = NextValidatorRateSvc(inner);
-                        let codec = tonic::codec::ProstCodec::default();
-                        let mut grpc = tonic::server::Grpc::new(codec)
-                            .apply_compression_config(
-                                accept_compression_encodings,
-                                send_compression_encodings,
-                            );
-                        let res = grpc.unary(method, req).await;
-                        Ok(res)
-                    };
-                    Box::pin(fut)
-                }
                 "/penumbra.client.v1alpha1.SpecificQueryService/CurrentValidatorRate" => {
                     #[allow(non_camel_case_types)]
                     struct CurrentValidatorRateSvc<T: SpecificQueryService>(pub Arc<T>);
diff --git a/crates/proto/src/gen/penumbra.client.v1alpha1.serde.rs b/crates/proto/src/gen/penumbra.client.v1alpha1.serde.rs
index bbbca1172b..8b0270186e 100644
--- a/crates/proto/src/gen/penumbra.client.v1alpha1.serde.rs
+++ b/crates/proto/src/gen/penumbra.client.v1alpha1.serde.rs
@@ -4275,207 +4275,6 @@ impl<'de> serde::Deserialize<'de> for LiquidityPositionsResponse {
         deserializer.deserialize_struct("penumbra.client.v1alpha1.LiquidityPositionsResponse", FIELDS, GeneratedVisitor)
     }
 }
-impl serde::Serialize for NextValidatorRateRequest {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.chain_id.is_empty() {
-            len += 1;
-        }
-        if self.identity_key.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("penumbra.client.v1alpha1.NextValidatorRateRequest", len)?;
-        if !self.chain_id.is_empty() {
-            struct_ser.serialize_field("chainId", &self.chain_id)?;
-        }
-        if let Some(v) = self.identity_key.as_ref() {
-            struct_ser.serialize_field("identityKey", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for NextValidatorRateRequest {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "chain_id",
-            "chainId",
-            "identity_key",
-            "identityKey",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            ChainId,
-            IdentityKey,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "chainId" | "chain_id" => Ok(GeneratedField::ChainId),
-                            "identityKey" | "identity_key" => Ok(GeneratedField::IdentityKey),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = NextValidatorRateRequest;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct penumbra.client.v1alpha1.NextValidatorRateRequest")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<NextValidatorRateRequest, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut chain_id__ = None;
-                let mut identity_key__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::ChainId => {
-                            if chain_id__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("chainId"));
-                            }
-                            chain_id__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::IdentityKey => {
-                            if identity_key__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("identityKey"));
-                            }
-                            identity_key__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(NextValidatorRateRequest {
-                    chain_id: chain_id__.unwrap_or_default(),
-                    identity_key: identity_key__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("penumbra.client.v1alpha1.NextValidatorRateRequest", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for NextValidatorRateResponse {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.data.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("penumbra.client.v1alpha1.NextValidatorRateResponse", len)?;
-        if let Some(v) = self.data.as_ref() {
-            struct_ser.serialize_field("data", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for NextValidatorRateResponse {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "data",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Data,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "data" => Ok(GeneratedField::Data),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = NextValidatorRateResponse;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct penumbra.client.v1alpha1.NextValidatorRateResponse")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<NextValidatorRateResponse, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut data__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Data => {
-                            if data__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("data"));
-                            }
-                            data__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(NextValidatorRateResponse {
-                    data: data__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("penumbra.client.v1alpha1.NextValidatorRateResponse", FIELDS, GeneratedVisitor)
-    }
-}
 impl serde::Serialize for PrefixValueRequest {
     #[allow(deprecated)]
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
diff --git a/crates/proto/src/gen/proto_descriptor.bin b/crates/proto/src/gen/proto_descriptor.bin
index d5e8f620bf..2c9ea7c1e3 100644
--- a/crates/proto/src/gen/proto_descriptor.bin
+++ b/crates/proto/src/gen/proto_descriptor.bin
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5ccb0713140004199bb2871bea1987d6c80cc19b21d3d594481da948e7adcc46
-size 332209
+oid sha256:bccb4ba629babe024de43725d9925ee89dfca401bd562130e9faf439d1ce3f63
+size 331509
diff --git a/proto/go/gen/penumbra/client/v1alpha1/client.pb.go b/proto/go/gen/penumbra/client/v1alpha1/client.pb.go
index 410446a3db..5712f83fef 100644
--- a/proto/go/gen/penumbra/client/v1alpha1/client.pb.go
+++ b/proto/go/gen/penumbra/client/v1alpha1/client.pb.go
@@ -1038,109 +1038,6 @@ func (x *CurrentValidatorRateResponse) GetData() *v1alpha11.RateData {
 	return nil
 }
 
-type NextValidatorRateRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The expected chain id (empty string if no expectation).
-	ChainId     string                 `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
-	IdentityKey *v1alpha12.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
-}
-
-func (x *NextValidatorRateRequest) Reset() {
-	*x = NextValidatorRateRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[18]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *NextValidatorRateRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*NextValidatorRateRequest) ProtoMessage() {}
-
-func (x *NextValidatorRateRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[18]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use NextValidatorRateRequest.ProtoReflect.Descriptor instead.
-func (*NextValidatorRateRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{18}
-}
-
-func (x *NextValidatorRateRequest) GetChainId() string {
-	if x != nil {
-		return x.ChainId
-	}
-	return ""
-}
-
-func (x *NextValidatorRateRequest) GetIdentityKey() *v1alpha12.IdentityKey {
-	if x != nil {
-		return x.IdentityKey
-	}
-	return nil
-}
-
-type NextValidatorRateResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Data *v1alpha11.RateData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
-}
-
-func (x *NextValidatorRateResponse) Reset() {
-	*x = NextValidatorRateResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[19]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *NextValidatorRateResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*NextValidatorRateResponse) ProtoMessage() {}
-
-func (x *NextValidatorRateResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[19]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use NextValidatorRateResponse.ProtoReflect.Descriptor instead.
-func (*NextValidatorRateResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{19}
-}
-
-func (x *NextValidatorRateResponse) GetData() *v1alpha11.RateData {
-	if x != nil {
-		return x.Data
-	}
-	return nil
-}
-
 // Requests batch swap data associated with a given height and trading pair from the view service.
 type BatchSwapOutputDataRequest struct {
 	state         protoimpl.MessageState
@@ -1156,7 +1053,7 @@ type BatchSwapOutputDataRequest struct {
 func (x *BatchSwapOutputDataRequest) Reset() {
 	*x = BatchSwapOutputDataRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[20]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[18]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1169,7 +1066,7 @@ func (x *BatchSwapOutputDataRequest) String() string {
 func (*BatchSwapOutputDataRequest) ProtoMessage() {}
 
 func (x *BatchSwapOutputDataRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[20]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[18]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1182,7 +1079,7 @@ func (x *BatchSwapOutputDataRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BatchSwapOutputDataRequest.ProtoReflect.Descriptor instead.
 func (*BatchSwapOutputDataRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{20}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{18}
 }
 
 func (x *BatchSwapOutputDataRequest) GetChainId() string {
@@ -1217,7 +1114,7 @@ type BatchSwapOutputDataResponse struct {
 func (x *BatchSwapOutputDataResponse) Reset() {
 	*x = BatchSwapOutputDataResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[21]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[19]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1230,7 +1127,7 @@ func (x *BatchSwapOutputDataResponse) String() string {
 func (*BatchSwapOutputDataResponse) ProtoMessage() {}
 
 func (x *BatchSwapOutputDataResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[21]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[19]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1243,7 +1140,7 @@ func (x *BatchSwapOutputDataResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BatchSwapOutputDataResponse.ProtoReflect.Descriptor instead.
 func (*BatchSwapOutputDataResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{21}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{19}
 }
 
 func (x *BatchSwapOutputDataResponse) GetData() *v1alpha13.BatchSwapOutputData {
@@ -1267,7 +1164,7 @@ type SwapExecutionRequest struct {
 func (x *SwapExecutionRequest) Reset() {
 	*x = SwapExecutionRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[22]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1280,7 +1177,7 @@ func (x *SwapExecutionRequest) String() string {
 func (*SwapExecutionRequest) ProtoMessage() {}
 
 func (x *SwapExecutionRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[22]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[20]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1293,7 +1190,7 @@ func (x *SwapExecutionRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SwapExecutionRequest.ProtoReflect.Descriptor instead.
 func (*SwapExecutionRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{22}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{20}
 }
 
 func (x *SwapExecutionRequest) GetChainId() string {
@@ -1328,7 +1225,7 @@ type SwapExecutionResponse struct {
 func (x *SwapExecutionResponse) Reset() {
 	*x = SwapExecutionResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[23]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[21]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1341,7 +1238,7 @@ func (x *SwapExecutionResponse) String() string {
 func (*SwapExecutionResponse) ProtoMessage() {}
 
 func (x *SwapExecutionResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[23]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[21]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1354,7 +1251,7 @@ func (x *SwapExecutionResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SwapExecutionResponse.ProtoReflect.Descriptor instead.
 func (*SwapExecutionResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{23}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{21}
 }
 
 func (x *SwapExecutionResponse) GetSwapExecution() *v1alpha13.SwapExecution {
@@ -1377,7 +1274,7 @@ type ArbExecutionRequest struct {
 func (x *ArbExecutionRequest) Reset() {
 	*x = ArbExecutionRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[24]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[22]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1390,7 +1287,7 @@ func (x *ArbExecutionRequest) String() string {
 func (*ArbExecutionRequest) ProtoMessage() {}
 
 func (x *ArbExecutionRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[24]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[22]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1403,7 +1300,7 @@ func (x *ArbExecutionRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ArbExecutionRequest.ProtoReflect.Descriptor instead.
 func (*ArbExecutionRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{24}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{22}
 }
 
 func (x *ArbExecutionRequest) GetChainId() string {
@@ -1432,7 +1329,7 @@ type ArbExecutionResponse struct {
 func (x *ArbExecutionResponse) Reset() {
 	*x = ArbExecutionResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[25]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[23]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1445,7 +1342,7 @@ func (x *ArbExecutionResponse) String() string {
 func (*ArbExecutionResponse) ProtoMessage() {}
 
 func (x *ArbExecutionResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[25]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[23]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1458,7 +1355,7 @@ func (x *ArbExecutionResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ArbExecutionResponse.ProtoReflect.Descriptor instead.
 func (*ArbExecutionResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{25}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{23}
 }
 
 func (x *ArbExecutionResponse) GetSwapExecution() *v1alpha13.SwapExecution {
@@ -1493,7 +1390,7 @@ type SwapExecutionsRequest struct {
 func (x *SwapExecutionsRequest) Reset() {
 	*x = SwapExecutionsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[26]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[24]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1506,7 +1403,7 @@ func (x *SwapExecutionsRequest) String() string {
 func (*SwapExecutionsRequest) ProtoMessage() {}
 
 func (x *SwapExecutionsRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[26]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[24]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1519,7 +1416,7 @@ func (x *SwapExecutionsRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SwapExecutionsRequest.ProtoReflect.Descriptor instead.
 func (*SwapExecutionsRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{26}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{24}
 }
 
 func (x *SwapExecutionsRequest) GetChainId() string {
@@ -1563,7 +1460,7 @@ type SwapExecutionsResponse struct {
 func (x *SwapExecutionsResponse) Reset() {
 	*x = SwapExecutionsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[27]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[25]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1576,7 +1473,7 @@ func (x *SwapExecutionsResponse) String() string {
 func (*SwapExecutionsResponse) ProtoMessage() {}
 
 func (x *SwapExecutionsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[27]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[25]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1589,7 +1486,7 @@ func (x *SwapExecutionsResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SwapExecutionsResponse.ProtoReflect.Descriptor instead.
 func (*SwapExecutionsResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{27}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{25}
 }
 
 func (x *SwapExecutionsResponse) GetSwapExecution() *v1alpha13.SwapExecution {
@@ -1629,7 +1526,7 @@ type ArbExecutionsRequest struct {
 func (x *ArbExecutionsRequest) Reset() {
 	*x = ArbExecutionsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[28]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[26]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1642,7 +1539,7 @@ func (x *ArbExecutionsRequest) String() string {
 func (*ArbExecutionsRequest) ProtoMessage() {}
 
 func (x *ArbExecutionsRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[28]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[26]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1655,7 +1552,7 @@ func (x *ArbExecutionsRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ArbExecutionsRequest.ProtoReflect.Descriptor instead.
 func (*ArbExecutionsRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{28}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{26}
 }
 
 func (x *ArbExecutionsRequest) GetChainId() string {
@@ -1691,7 +1588,7 @@ type ArbExecutionsResponse struct {
 func (x *ArbExecutionsResponse) Reset() {
 	*x = ArbExecutionsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[29]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[27]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1704,7 +1601,7 @@ func (x *ArbExecutionsResponse) String() string {
 func (*ArbExecutionsResponse) ProtoMessage() {}
 
 func (x *ArbExecutionsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[29]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[27]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1717,7 +1614,7 @@ func (x *ArbExecutionsResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ArbExecutionsResponse.ProtoReflect.Descriptor instead.
 func (*ArbExecutionsResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{29}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{27}
 }
 
 func (x *ArbExecutionsResponse) GetSwapExecution() *v1alpha13.SwapExecution {
@@ -1749,7 +1646,7 @@ type LiquidityPositionsRequest struct {
 func (x *LiquidityPositionsRequest) Reset() {
 	*x = LiquidityPositionsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[30]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[28]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1762,7 +1659,7 @@ func (x *LiquidityPositionsRequest) String() string {
 func (*LiquidityPositionsRequest) ProtoMessage() {}
 
 func (x *LiquidityPositionsRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[30]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[28]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1775,7 +1672,7 @@ func (x *LiquidityPositionsRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LiquidityPositionsRequest.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionsRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{30}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{28}
 }
 
 func (x *LiquidityPositionsRequest) GetChainId() string {
@@ -1803,7 +1700,7 @@ type LiquidityPositionsResponse struct {
 func (x *LiquidityPositionsResponse) Reset() {
 	*x = LiquidityPositionsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[31]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[29]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1816,7 +1713,7 @@ func (x *LiquidityPositionsResponse) String() string {
 func (*LiquidityPositionsResponse) ProtoMessage() {}
 
 func (x *LiquidityPositionsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[31]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[29]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1829,7 +1726,7 @@ func (x *LiquidityPositionsResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LiquidityPositionsResponse.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionsResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{31}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{29}
 }
 
 func (x *LiquidityPositionsResponse) GetData() *v1alpha13.Position {
@@ -1856,7 +1753,7 @@ type LiquidityPositionsByPriceRequest struct {
 func (x *LiquidityPositionsByPriceRequest) Reset() {
 	*x = LiquidityPositionsByPriceRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[32]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[30]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1869,7 +1766,7 @@ func (x *LiquidityPositionsByPriceRequest) String() string {
 func (*LiquidityPositionsByPriceRequest) ProtoMessage() {}
 
 func (x *LiquidityPositionsByPriceRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[32]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[30]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1882,7 +1779,7 @@ func (x *LiquidityPositionsByPriceRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LiquidityPositionsByPriceRequest.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionsByPriceRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{32}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{30}
 }
 
 func (x *LiquidityPositionsByPriceRequest) GetChainId() string {
@@ -1917,7 +1814,7 @@ type LiquidityPositionsByPriceResponse struct {
 func (x *LiquidityPositionsByPriceResponse) Reset() {
 	*x = LiquidityPositionsByPriceResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[33]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[31]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1930,7 +1827,7 @@ func (x *LiquidityPositionsByPriceResponse) String() string {
 func (*LiquidityPositionsByPriceResponse) ProtoMessage() {}
 
 func (x *LiquidityPositionsByPriceResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[33]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[31]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1943,7 +1840,7 @@ func (x *LiquidityPositionsByPriceResponse) ProtoReflect() protoreflect.Message
 
 // Deprecated: Use LiquidityPositionsByPriceResponse.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionsByPriceResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{33}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{31}
 }
 
 func (x *LiquidityPositionsByPriceResponse) GetData() *v1alpha13.Position {
@@ -1967,7 +1864,7 @@ type LiquidityPositionByIdRequest struct {
 func (x *LiquidityPositionByIdRequest) Reset() {
 	*x = LiquidityPositionByIdRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[34]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[32]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1980,7 +1877,7 @@ func (x *LiquidityPositionByIdRequest) String() string {
 func (*LiquidityPositionByIdRequest) ProtoMessage() {}
 
 func (x *LiquidityPositionByIdRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[34]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[32]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1993,7 +1890,7 @@ func (x *LiquidityPositionByIdRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LiquidityPositionByIdRequest.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionByIdRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{34}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{32}
 }
 
 func (x *LiquidityPositionByIdRequest) GetChainId() string {
@@ -2021,7 +1918,7 @@ type LiquidityPositionByIdResponse struct {
 func (x *LiquidityPositionByIdResponse) Reset() {
 	*x = LiquidityPositionByIdResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[35]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[33]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2034,7 +1931,7 @@ func (x *LiquidityPositionByIdResponse) String() string {
 func (*LiquidityPositionByIdResponse) ProtoMessage() {}
 
 func (x *LiquidityPositionByIdResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[35]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[33]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2047,7 +1944,7 @@ func (x *LiquidityPositionByIdResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LiquidityPositionByIdResponse.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionByIdResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{35}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{33}
 }
 
 func (x *LiquidityPositionByIdResponse) GetData() *v1alpha13.Position {
@@ -2070,7 +1967,7 @@ type LiquidityPositionsByIdRequest struct {
 func (x *LiquidityPositionsByIdRequest) Reset() {
 	*x = LiquidityPositionsByIdRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[36]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[34]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2083,7 +1980,7 @@ func (x *LiquidityPositionsByIdRequest) String() string {
 func (*LiquidityPositionsByIdRequest) ProtoMessage() {}
 
 func (x *LiquidityPositionsByIdRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[36]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[34]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2096,7 +1993,7 @@ func (x *LiquidityPositionsByIdRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LiquidityPositionsByIdRequest.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionsByIdRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{36}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{34}
 }
 
 func (x *LiquidityPositionsByIdRequest) GetChainId() string {
@@ -2124,7 +2021,7 @@ type LiquidityPositionsByIdResponse struct {
 func (x *LiquidityPositionsByIdResponse) Reset() {
 	*x = LiquidityPositionsByIdResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[37]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[35]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2137,7 +2034,7 @@ func (x *LiquidityPositionsByIdResponse) String() string {
 func (*LiquidityPositionsByIdResponse) ProtoMessage() {}
 
 func (x *LiquidityPositionsByIdResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[37]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[35]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2150,7 +2047,7 @@ func (x *LiquidityPositionsByIdResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use LiquidityPositionsByIdResponse.ProtoReflect.Descriptor instead.
 func (*LiquidityPositionsByIdResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{37}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{35}
 }
 
 func (x *LiquidityPositionsByIdResponse) GetData() *v1alpha13.Position {
@@ -2173,7 +2070,7 @@ type SpreadRequest struct {
 func (x *SpreadRequest) Reset() {
 	*x = SpreadRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[38]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[36]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2186,7 +2083,7 @@ func (x *SpreadRequest) String() string {
 func (*SpreadRequest) ProtoMessage() {}
 
 func (x *SpreadRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[38]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[36]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2199,7 +2096,7 @@ func (x *SpreadRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SpreadRequest.ProtoReflect.Descriptor instead.
 func (*SpreadRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{38}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{36}
 }
 
 func (x *SpreadRequest) GetChainId() string {
@@ -2234,7 +2131,7 @@ type SpreadResponse struct {
 func (x *SpreadResponse) Reset() {
 	*x = SpreadResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[39]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[37]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2247,7 +2144,7 @@ func (x *SpreadResponse) String() string {
 func (*SpreadResponse) ProtoMessage() {}
 
 func (x *SpreadResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[39]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[37]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2260,7 +2157,7 @@ func (x *SpreadResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SpreadResponse.ProtoReflect.Descriptor instead.
 func (*SpreadResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{39}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{37}
 }
 
 func (x *SpreadResponse) GetBest_1To_2Position() *v1alpha13.Position {
@@ -2306,7 +2203,7 @@ type DenomMetadataByIdRequest struct {
 func (x *DenomMetadataByIdRequest) Reset() {
 	*x = DenomMetadataByIdRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[40]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[38]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2319,7 +2216,7 @@ func (x *DenomMetadataByIdRequest) String() string {
 func (*DenomMetadataByIdRequest) ProtoMessage() {}
 
 func (x *DenomMetadataByIdRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[40]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[38]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2332,7 +2229,7 @@ func (x *DenomMetadataByIdRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DenomMetadataByIdRequest.ProtoReflect.Descriptor instead.
 func (*DenomMetadataByIdRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{40}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{38}
 }
 
 func (x *DenomMetadataByIdRequest) GetChainId() string {
@@ -2363,7 +2260,7 @@ type DenomMetadataByIdResponse struct {
 func (x *DenomMetadataByIdResponse) Reset() {
 	*x = DenomMetadataByIdResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[41]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[39]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2376,7 +2273,7 @@ func (x *DenomMetadataByIdResponse) String() string {
 func (*DenomMetadataByIdResponse) ProtoMessage() {}
 
 func (x *DenomMetadataByIdResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[41]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[39]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2389,7 +2286,7 @@ func (x *DenomMetadataByIdResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DenomMetadataByIdResponse.ProtoReflect.Descriptor instead.
 func (*DenomMetadataByIdResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{41}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{39}
 }
 
 func (x *DenomMetadataByIdResponse) GetDenomMetadata() *v1alpha12.DenomMetadata {
@@ -2413,7 +2310,7 @@ type ProposalInfoRequest struct {
 func (x *ProposalInfoRequest) Reset() {
 	*x = ProposalInfoRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[42]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[40]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2426,7 +2323,7 @@ func (x *ProposalInfoRequest) String() string {
 func (*ProposalInfoRequest) ProtoMessage() {}
 
 func (x *ProposalInfoRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[42]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[40]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2439,7 +2336,7 @@ func (x *ProposalInfoRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ProposalInfoRequest.ProtoReflect.Descriptor instead.
 func (*ProposalInfoRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{42}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{40}
 }
 
 func (x *ProposalInfoRequest) GetChainId() string {
@@ -2470,7 +2367,7 @@ type ProposalInfoResponse struct {
 func (x *ProposalInfoResponse) Reset() {
 	*x = ProposalInfoResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[43]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[41]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2483,7 +2380,7 @@ func (x *ProposalInfoResponse) String() string {
 func (*ProposalInfoResponse) ProtoMessage() {}
 
 func (x *ProposalInfoResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[43]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[41]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2496,7 +2393,7 @@ func (x *ProposalInfoResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ProposalInfoResponse.ProtoReflect.Descriptor instead.
 func (*ProposalInfoResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{43}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{41}
 }
 
 func (x *ProposalInfoResponse) GetStartBlockHeight() uint64 {
@@ -2528,7 +2425,7 @@ type ProposalRateDataRequest struct {
 func (x *ProposalRateDataRequest) Reset() {
 	*x = ProposalRateDataRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[44]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[42]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2541,7 +2438,7 @@ func (x *ProposalRateDataRequest) String() string {
 func (*ProposalRateDataRequest) ProtoMessage() {}
 
 func (x *ProposalRateDataRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[44]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[42]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2554,7 +2451,7 @@ func (x *ProposalRateDataRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ProposalRateDataRequest.ProtoReflect.Descriptor instead.
 func (*ProposalRateDataRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{44}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{42}
 }
 
 func (x *ProposalRateDataRequest) GetChainId() string {
@@ -2583,7 +2480,7 @@ type ProposalRateDataResponse struct {
 func (x *ProposalRateDataResponse) Reset() {
 	*x = ProposalRateDataResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[45]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[43]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2596,7 +2493,7 @@ func (x *ProposalRateDataResponse) String() string {
 func (*ProposalRateDataResponse) ProtoMessage() {}
 
 func (x *ProposalRateDataResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[45]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[43]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2609,7 +2506,7 @@ func (x *ProposalRateDataResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ProposalRateDataResponse.ProtoReflect.Descriptor instead.
 func (*ProposalRateDataResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{45}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{43}
 }
 
 func (x *ProposalRateDataResponse) GetRateData() *v1alpha11.RateData {
@@ -2632,7 +2529,7 @@ type SimulateTradeRequest struct {
 func (x *SimulateTradeRequest) Reset() {
 	*x = SimulateTradeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[46]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[44]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2645,7 +2542,7 @@ func (x *SimulateTradeRequest) String() string {
 func (*SimulateTradeRequest) ProtoMessage() {}
 
 func (x *SimulateTradeRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[46]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[44]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2658,7 +2555,7 @@ func (x *SimulateTradeRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SimulateTradeRequest.ProtoReflect.Descriptor instead.
 func (*SimulateTradeRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{46}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{44}
 }
 
 func (x *SimulateTradeRequest) GetInput() *v1alpha12.Value {
@@ -2693,7 +2590,7 @@ type SimulateTradeResponse struct {
 func (x *SimulateTradeResponse) Reset() {
 	*x = SimulateTradeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[47]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[45]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2706,7 +2603,7 @@ func (x *SimulateTradeResponse) String() string {
 func (*SimulateTradeResponse) ProtoMessage() {}
 
 func (x *SimulateTradeResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[47]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[45]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2719,7 +2616,7 @@ func (x *SimulateTradeResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SimulateTradeResponse.ProtoReflect.Descriptor instead.
 func (*SimulateTradeResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{47}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{45}
 }
 
 func (x *SimulateTradeResponse) GetOutput() *v1alpha13.SwapExecution {
@@ -2748,7 +2645,7 @@ type KeyValueRequest struct {
 func (x *KeyValueRequest) Reset() {
 	*x = KeyValueRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[48]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[46]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2761,7 +2658,7 @@ func (x *KeyValueRequest) String() string {
 func (*KeyValueRequest) ProtoMessage() {}
 
 func (x *KeyValueRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[48]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[46]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2774,7 +2671,7 @@ func (x *KeyValueRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use KeyValueRequest.ProtoReflect.Descriptor instead.
 func (*KeyValueRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{48}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{46}
 }
 
 func (x *KeyValueRequest) GetChainId() string {
@@ -2812,7 +2709,7 @@ type KeyValueResponse struct {
 func (x *KeyValueResponse) Reset() {
 	*x = KeyValueResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[49]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[47]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2825,7 +2722,7 @@ func (x *KeyValueResponse) String() string {
 func (*KeyValueResponse) ProtoMessage() {}
 
 func (x *KeyValueResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[49]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[47]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2838,7 +2735,7 @@ func (x *KeyValueResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use KeyValueResponse.ProtoReflect.Descriptor instead.
 func (*KeyValueResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{49}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{47}
 }
 
 func (x *KeyValueResponse) GetValue() *KeyValueResponse_Value {
@@ -2870,7 +2767,7 @@ type PrefixValueRequest struct {
 func (x *PrefixValueRequest) Reset() {
 	*x = PrefixValueRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[50]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[48]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2883,7 +2780,7 @@ func (x *PrefixValueRequest) String() string {
 func (*PrefixValueRequest) ProtoMessage() {}
 
 func (x *PrefixValueRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[50]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[48]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2896,7 +2793,7 @@ func (x *PrefixValueRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use PrefixValueRequest.ProtoReflect.Descriptor instead.
 func (*PrefixValueRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{50}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{48}
 }
 
 func (x *PrefixValueRequest) GetChainId() string {
@@ -2925,7 +2822,7 @@ type PrefixValueResponse struct {
 func (x *PrefixValueResponse) Reset() {
 	*x = PrefixValueResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[51]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[49]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2938,7 +2835,7 @@ func (x *PrefixValueResponse) String() string {
 func (*PrefixValueResponse) ProtoMessage() {}
 
 func (x *PrefixValueResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[51]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[49]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2951,7 +2848,7 @@ func (x *PrefixValueResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use PrefixValueResponse.ProtoReflect.Descriptor instead.
 func (*PrefixValueResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{51}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{49}
 }
 
 func (x *PrefixValueResponse) GetKey() string {
@@ -2983,7 +2880,7 @@ type GetTxRequest struct {
 func (x *GetTxRequest) Reset() {
 	*x = GetTxRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[52]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[50]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2996,7 +2893,7 @@ func (x *GetTxRequest) String() string {
 func (*GetTxRequest) ProtoMessage() {}
 
 func (x *GetTxRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[52]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[50]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3009,7 +2906,7 @@ func (x *GetTxRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use GetTxRequest.ProtoReflect.Descriptor instead.
 func (*GetTxRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{52}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{50}
 }
 
 func (x *GetTxRequest) GetHash() []byte {
@@ -3043,7 +2940,7 @@ type GetTxResponse struct {
 func (x *GetTxResponse) Reset() {
 	*x = GetTxResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[53]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[51]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3056,7 +2953,7 @@ func (x *GetTxResponse) String() string {
 func (*GetTxResponse) ProtoMessage() {}
 
 func (x *GetTxResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[53]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[51]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3069,7 +2966,7 @@ func (x *GetTxResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use GetTxResponse.ProtoReflect.Descriptor instead.
 func (*GetTxResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{53}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{51}
 }
 
 func (x *GetTxResponse) GetHash() []byte {
@@ -3121,7 +3018,7 @@ type TxResult struct {
 func (x *TxResult) Reset() {
 	*x = TxResult{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[54]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[52]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3134,7 +3031,7 @@ func (x *TxResult) String() string {
 func (*TxResult) ProtoMessage() {}
 
 func (x *TxResult) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[54]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[52]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3147,7 +3044,7 @@ func (x *TxResult) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use TxResult.ProtoReflect.Descriptor instead.
 func (*TxResult) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{54}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{52}
 }
 
 func (x *TxResult) GetLog() string {
@@ -3191,7 +3088,7 @@ type Tag struct {
 func (x *Tag) Reset() {
 	*x = Tag{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[55]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[53]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3204,7 +3101,7 @@ func (x *Tag) String() string {
 func (*Tag) ProtoMessage() {}
 
 func (x *Tag) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[55]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[53]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3217,7 +3114,7 @@ func (x *Tag) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Tag.ProtoReflect.Descriptor instead.
 func (*Tag) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{55}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{53}
 }
 
 func (x *Tag) GetKey() []byte {
@@ -3254,7 +3151,7 @@ type BroadcastTxAsyncRequest struct {
 func (x *BroadcastTxAsyncRequest) Reset() {
 	*x = BroadcastTxAsyncRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[56]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[54]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3267,7 +3164,7 @@ func (x *BroadcastTxAsyncRequest) String() string {
 func (*BroadcastTxAsyncRequest) ProtoMessage() {}
 
 func (x *BroadcastTxAsyncRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[56]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[54]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3280,7 +3177,7 @@ func (x *BroadcastTxAsyncRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BroadcastTxAsyncRequest.ProtoReflect.Descriptor instead.
 func (*BroadcastTxAsyncRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{56}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{54}
 }
 
 func (x *BroadcastTxAsyncRequest) GetParams() []byte {
@@ -3312,7 +3209,7 @@ type BroadcastTxAsyncResponse struct {
 func (x *BroadcastTxAsyncResponse) Reset() {
 	*x = BroadcastTxAsyncResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[57]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[55]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3325,7 +3222,7 @@ func (x *BroadcastTxAsyncResponse) String() string {
 func (*BroadcastTxAsyncResponse) ProtoMessage() {}
 
 func (x *BroadcastTxAsyncResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[57]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[55]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3338,7 +3235,7 @@ func (x *BroadcastTxAsyncResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BroadcastTxAsyncResponse.ProtoReflect.Descriptor instead.
 func (*BroadcastTxAsyncResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{57}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{55}
 }
 
 func (x *BroadcastTxAsyncResponse) GetCode() uint64 {
@@ -3382,7 +3279,7 @@ type BroadcastTxSyncRequest struct {
 func (x *BroadcastTxSyncRequest) Reset() {
 	*x = BroadcastTxSyncRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[58]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[56]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3395,7 +3292,7 @@ func (x *BroadcastTxSyncRequest) String() string {
 func (*BroadcastTxSyncRequest) ProtoMessage() {}
 
 func (x *BroadcastTxSyncRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[58]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[56]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3408,7 +3305,7 @@ func (x *BroadcastTxSyncRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BroadcastTxSyncRequest.ProtoReflect.Descriptor instead.
 func (*BroadcastTxSyncRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{58}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{56}
 }
 
 func (x *BroadcastTxSyncRequest) GetParams() []byte {
@@ -3440,7 +3337,7 @@ type BroadcastTxSyncResponse struct {
 func (x *BroadcastTxSyncResponse) Reset() {
 	*x = BroadcastTxSyncResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[59]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[57]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3453,7 +3350,7 @@ func (x *BroadcastTxSyncResponse) String() string {
 func (*BroadcastTxSyncResponse) ProtoMessage() {}
 
 func (x *BroadcastTxSyncResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[59]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[57]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3466,7 +3363,7 @@ func (x *BroadcastTxSyncResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BroadcastTxSyncResponse.ProtoReflect.Descriptor instead.
 func (*BroadcastTxSyncResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{59}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{57}
 }
 
 func (x *BroadcastTxSyncResponse) GetCode() uint64 {
@@ -3507,7 +3404,7 @@ type GetStatusRequest struct {
 func (x *GetStatusRequest) Reset() {
 	*x = GetStatusRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[60]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[58]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3520,7 +3417,7 @@ func (x *GetStatusRequest) String() string {
 func (*GetStatusRequest) ProtoMessage() {}
 
 func (x *GetStatusRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[60]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[58]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3533,7 +3430,7 @@ func (x *GetStatusRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use GetStatusRequest.ProtoReflect.Descriptor instead.
 func (*GetStatusRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{60}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{58}
 }
 
 // GetStatusResponse is the response type for the Query/GetStatus RPC method.
@@ -3550,7 +3447,7 @@ type GetStatusResponse struct {
 func (x *GetStatusResponse) Reset() {
 	*x = GetStatusResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[61]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[59]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3563,7 +3460,7 @@ func (x *GetStatusResponse) String() string {
 func (*GetStatusResponse) ProtoMessage() {}
 
 func (x *GetStatusResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[61]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[59]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3576,7 +3473,7 @@ func (x *GetStatusResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use GetStatusResponse.ProtoReflect.Descriptor instead.
 func (*GetStatusResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{61}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{59}
 }
 
 func (x *GetStatusResponse) GetNodeInfo() *p2p.DefaultNodeInfo {
@@ -3621,7 +3518,7 @@ type SyncInfo struct {
 func (x *SyncInfo) Reset() {
 	*x = SyncInfo{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[62]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[60]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3634,7 +3531,7 @@ func (x *SyncInfo) String() string {
 func (*SyncInfo) ProtoMessage() {}
 
 func (x *SyncInfo) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[62]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[60]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3647,7 +3544,7 @@ func (x *SyncInfo) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SyncInfo.ProtoReflect.Descriptor instead.
 func (*SyncInfo) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{62}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{60}
 }
 
 func (x *SyncInfo) GetLatestBlockHash() []byte {
@@ -3700,7 +3597,7 @@ type ABCIQueryRequest struct {
 func (x *ABCIQueryRequest) Reset() {
 	*x = ABCIQueryRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[63]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[61]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3713,7 +3610,7 @@ func (x *ABCIQueryRequest) String() string {
 func (*ABCIQueryRequest) ProtoMessage() {}
 
 func (x *ABCIQueryRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[63]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[61]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3726,7 +3623,7 @@ func (x *ABCIQueryRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ABCIQueryRequest.ProtoReflect.Descriptor instead.
 func (*ABCIQueryRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{63}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{61}
 }
 
 func (x *ABCIQueryRequest) GetData() []byte {
@@ -3780,7 +3677,7 @@ type ABCIQueryResponse struct {
 func (x *ABCIQueryResponse) Reset() {
 	*x = ABCIQueryResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[64]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[62]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3793,7 +3690,7 @@ func (x *ABCIQueryResponse) String() string {
 func (*ABCIQueryResponse) ProtoMessage() {}
 
 func (x *ABCIQueryResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[64]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[62]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3806,7 +3703,7 @@ func (x *ABCIQueryResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ABCIQueryResponse.ProtoReflect.Descriptor instead.
 func (*ABCIQueryResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{64}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{62}
 }
 
 func (x *ABCIQueryResponse) GetCode() uint32 {
@@ -3884,7 +3781,7 @@ type GetBlockByHeightRequest struct {
 func (x *GetBlockByHeightRequest) Reset() {
 	*x = GetBlockByHeightRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[65]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[63]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3897,7 +3794,7 @@ func (x *GetBlockByHeightRequest) String() string {
 func (*GetBlockByHeightRequest) ProtoMessage() {}
 
 func (x *GetBlockByHeightRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[65]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[63]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3910,7 +3807,7 @@ func (x *GetBlockByHeightRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use GetBlockByHeightRequest.ProtoReflect.Descriptor instead.
 func (*GetBlockByHeightRequest) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{65}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{63}
 }
 
 func (x *GetBlockByHeightRequest) GetHeight() int64 {
@@ -3933,7 +3830,7 @@ type GetBlockByHeightResponse struct {
 func (x *GetBlockByHeightResponse) Reset() {
 	*x = GetBlockByHeightResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[66]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[64]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -3946,7 +3843,7 @@ func (x *GetBlockByHeightResponse) String() string {
 func (*GetBlockByHeightResponse) ProtoMessage() {}
 
 func (x *GetBlockByHeightResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[66]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[64]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3959,7 +3856,7 @@ func (x *GetBlockByHeightResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use GetBlockByHeightResponse.ProtoReflect.Descriptor instead.
 func (*GetBlockByHeightResponse) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{66}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{64}
 }
 
 func (x *GetBlockByHeightResponse) GetBlockId() *types1.BlockID {
@@ -3991,7 +3888,7 @@ type SimulateTradeRequest_Routing struct {
 func (x *SimulateTradeRequest_Routing) Reset() {
 	*x = SimulateTradeRequest_Routing{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[67]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[65]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -4004,7 +3901,7 @@ func (x *SimulateTradeRequest_Routing) String() string {
 func (*SimulateTradeRequest_Routing) ProtoMessage() {}
 
 func (x *SimulateTradeRequest_Routing) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[67]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[65]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4017,7 +3914,7 @@ func (x *SimulateTradeRequest_Routing) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SimulateTradeRequest_Routing.ProtoReflect.Descriptor instead.
 func (*SimulateTradeRequest_Routing) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{46, 0}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{44, 0}
 }
 
 func (m *SimulateTradeRequest_Routing) GetSetting() isSimulateTradeRequest_Routing_Setting {
@@ -4066,7 +3963,7 @@ type SimulateTradeRequest_Routing_SingleHop struct {
 func (x *SimulateTradeRequest_Routing_SingleHop) Reset() {
 	*x = SimulateTradeRequest_Routing_SingleHop{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[68]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[66]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -4079,7 +3976,7 @@ func (x *SimulateTradeRequest_Routing_SingleHop) String() string {
 func (*SimulateTradeRequest_Routing_SingleHop) ProtoMessage() {}
 
 func (x *SimulateTradeRequest_Routing_SingleHop) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[68]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[66]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4092,7 +3989,7 @@ func (x *SimulateTradeRequest_Routing_SingleHop) ProtoReflect() protoreflect.Mes
 
 // Deprecated: Use SimulateTradeRequest_Routing_SingleHop.ProtoReflect.Descriptor instead.
 func (*SimulateTradeRequest_Routing_SingleHop) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{46, 0, 0}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{44, 0, 0}
 }
 
 type SimulateTradeRequest_Routing_Default struct {
@@ -4104,7 +4001,7 @@ type SimulateTradeRequest_Routing_Default struct {
 func (x *SimulateTradeRequest_Routing_Default) Reset() {
 	*x = SimulateTradeRequest_Routing_Default{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[69]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[67]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -4117,7 +4014,7 @@ func (x *SimulateTradeRequest_Routing_Default) String() string {
 func (*SimulateTradeRequest_Routing_Default) ProtoMessage() {}
 
 func (x *SimulateTradeRequest_Routing_Default) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[69]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[67]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4130,7 +4027,7 @@ func (x *SimulateTradeRequest_Routing_Default) ProtoReflect() protoreflect.Messa
 
 // Deprecated: Use SimulateTradeRequest_Routing_Default.ProtoReflect.Descriptor instead.
 func (*SimulateTradeRequest_Routing_Default) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{46, 0, 1}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{44, 0, 1}
 }
 
 type KeyValueResponse_Value struct {
@@ -4144,7 +4041,7 @@ type KeyValueResponse_Value struct {
 func (x *KeyValueResponse_Value) Reset() {
 	*x = KeyValueResponse_Value{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[70]
+		mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[68]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -4157,7 +4054,7 @@ func (x *KeyValueResponse_Value) String() string {
 func (*KeyValueResponse_Value) ProtoMessage() {}
 
 func (x *KeyValueResponse_Value) ProtoReflect() protoreflect.Message {
-	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[70]
+	mi := &file_penumbra_client_v1alpha1_client_proto_msgTypes[68]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4170,7 +4067,7 @@ func (x *KeyValueResponse_Value) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use KeyValueResponse_Value.ProtoReflect.Descriptor instead.
 func (*KeyValueResponse_Value) Descriptor() ([]byte, []int) {
-	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{49, 0}
+	return file_penumbra_client_v1alpha1_client_proto_rawDescGZIP(), []int{47, 0}
 }
 
 func (x *KeyValueResponse_Value) GetValue() []byte {
@@ -4344,20 +4241,6 @@ var file_penumbra_client_v1alpha1_client_proto_rawDesc = []byte{
 	0x0b, 0x32, 0x26, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72,
 	0x65, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x65, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
 	0x2e, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22,
-	0x84, 0x01, 0x0a, 0x18, 0x4e, 0x65, 0x78, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
-	0x72, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08,
-	0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x4d, 0x0a, 0x0c, 0x69, 0x64, 0x65, 0x6e, 0x74,
-	0x69, 0x74, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e,
-	0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x72,
-	0x79, 0x70, 0x74, 0x6f, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x64,
-	0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x69, 0x64, 0x65, 0x6e, 0x74,
-	0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x22, 0x57, 0x0a, 0x19, 0x4e, 0x65, 0x78, 0x74, 0x56, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x26, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72,
-	0x65, 0x2e, 0x73, 0x74, 0x61, 0x6b, 0x65, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0x2e, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22,
 	0x9b, 0x01, 0x0a, 0x1a, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74,
 	0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19,
 	0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
@@ -4778,7 +4661,7 @@ var file_penumbra_client_v1alpha1_client_proto_rawDesc = []byte{
 	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
 	0x74, 0x1a, 0x26, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
 	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x49, 0x6e, 0x66,
-	0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xa0, 0x14, 0x0a, 0x14, 0x53, 0x70,
+	0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xa2, 0x13, 0x0a, 0x14, 0x53, 0x70,
 	0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69,
 	0x63, 0x65, 0x12, 0x7c, 0x0a, 0x11, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
 	0x6e, 0x42, 0x79, 0x4e, 0x6f, 0x74, 0x65, 0x12, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
@@ -4803,205 +4686,197 @@ var file_penumbra_client_v1alpha1_client_proto_rawDesc = []byte{
 	0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
 	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
 	0x61, 0x74, 0x6f, 0x72, 0x50, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x7c, 0x0a, 0x11, 0x4e, 0x65, 0x78, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74, 0x65, 0x12, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d,
-	0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
-	0x68, 0x61, 0x31, 0x2e, 0x4e, 0x65, 0x78, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
-	0x72, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x70,
+	0x6e, 0x73, 0x65, 0x12, 0x85, 0x01, 0x0a, 0x14, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74, 0x65, 0x12, 0x35, 0x2e, 0x70,
 	0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76,
-	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4e, 0x65, 0x78, 0x74, 0x56, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x85, 0x01, 0x0a, 0x14, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74, 0x65, 0x12, 0x35, 0x2e, 0x70, 0x65, 0x6e,
-	0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61,
-	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x36, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
-	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x75, 0x72,
-	0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x82, 0x01, 0x0a, 0x13, 0x42, 0x61,
-	0x74, 0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74,
-	0x61, 0x12, 0x34, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
-	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x61, 0x74,
-	0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
-	0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70,
-	0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x70,
-	0x0a, 0x0d, 0x53, 0x77, 0x61, 0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12,
-	0x2e, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x77, 0x61, 0x70, 0x45,
-	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x77, 0x61, 0x70, 0x45,
-	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x6d, 0x0a, 0x0c, 0x41, 0x72, 0x62, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
-	0x12, 0x2d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65,
-	0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x72, 0x62, 0x45,
-	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x2e, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x72, 0x62, 0x45, 0x78,
-	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x75, 0x0a, 0x0e, 0x53, 0x77, 0x61, 0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
+	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43,
+	0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52,
+	0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x82, 0x01, 0x0a, 0x13,
+	0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44,
+	0x61, 0x74, 0x61, 0x12, 0x34, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
+	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42,
+	0x61, 0x74, 0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61,
+	0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x70, 0x65, 0x6e, 0x75,
+	0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75,
+	0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x70, 0x0a, 0x0d, 0x53, 0x77, 0x61, 0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x2e, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
 	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x77, 0x61,
-	0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x30, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c,
-	0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x77,
-	0x61, 0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x72, 0x0a, 0x0d, 0x41, 0x72, 0x62, 0x45, 0x78, 0x65,
-	0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2e, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
-	0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x41, 0x72, 0x62, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
-	0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x41, 0x72, 0x62, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x81, 0x01, 0x0a, 0x12, 0x4c,
+	0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
+	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x77, 0x61,
+	0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x6d, 0x0a, 0x0c, 0x41, 0x72, 0x62, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c,
+	0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x72,
+	0x62, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x2e, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
+	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x72, 0x62,
+	0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x75, 0x0a, 0x0e, 0x53, 0x77, 0x61, 0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x12, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
+	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53,
+	0x77, 0x61, 0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e,
+	0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
+	0x53, 0x77, 0x61, 0x70, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x72, 0x0a, 0x0d, 0x41, 0x72, 0x62, 0x45,
+	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2e, 0x2e, 0x70, 0x65, 0x6e, 0x75,
+	0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x72, 0x62, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75,
+	0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x72, 0x62, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x81, 0x01, 0x0a,
+	0x12, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x12, 0x33, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
+	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c,
 	0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x33, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
-	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71,
-	0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72,
-	0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
-	0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x88,
-	0x01, 0x0a, 0x15, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69,
-	0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x49, 0x64, 0x12, 0x36, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d,
 	0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
 	0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73,
-	0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x37, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65,
-	0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75,
-	0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x49,
-	0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x8d, 0x01, 0x0a, 0x16, 0x4c, 0x69,
-	0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x42, 0x79, 0x49, 0x64, 0x12, 0x37, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e,
-	0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
+	0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01,
+	0x12, 0x88, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f,
+	0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x49, 0x64, 0x12, 0x36, 0x2e, 0x70, 0x65, 0x6e,
+	0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61,
+	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50,
+	0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x37, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c,
+	0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69,
+	0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x42,
+	0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x8d, 0x01, 0x0a, 0x16,
 	0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e,
-	0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e,
-	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69,
-	0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x79, 0x49, 0x64, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x96, 0x01, 0x0a, 0x19, 0x4c, 0x69,
-	0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x42, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x3a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
+	0x6e, 0x73, 0x42, 0x79, 0x49, 0x64, 0x12, 0x37, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72,
+	0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x38, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
+	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69,
+	0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x79, 0x49,
+	0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x96, 0x01, 0x0a, 0x19,
+	0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x42, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x3a, 0x2e, 0x70, 0x65, 0x6e, 0x75,
+	0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f,
+	0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3b, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61,
+	0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
+	0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x42, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x30, 0x01, 0x12, 0x5b, 0x0a, 0x06, 0x53, 0x70, 0x72, 0x65, 0x61, 0x64, 0x12, 0x27,
+	0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74,
+	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x70, 0x72, 0x65, 0x61, 0x64,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
 	0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x3b, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
-	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4c,
-	0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x42, 0x79, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x30, 0x01, 0x12, 0x5b, 0x0a, 0x06, 0x53, 0x70, 0x72, 0x65, 0x61, 0x64, 0x12, 0x27, 0x2e, 0x70,
-	0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76,
-	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x70, 0x72, 0x65, 0x61, 0x64, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61,
+	0x61, 0x31, 0x2e, 0x53, 0x70, 0x72, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x7c, 0x0a, 0x11, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+	0x74, 0x61, 0x42, 0x79, 0x49, 0x64, 0x12, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72,
+	0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x2e, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42,
+	0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x70, 0x65, 0x6e,
+	0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61,
+	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64,
+	0x61, 0x74, 0x61, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x6d, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12,
+	0x2d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
+	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f,
+	0x73, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e,
+	0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74,
+	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+	0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7b,
+	0x0a, 0x10, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61,
+	0x74, 0x61, 0x12, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c,
+	0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72,
+	0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61,
 	0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0x2e, 0x53, 0x70, 0x72, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x7c, 0x0a, 0x11, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
-	0x42, 0x79, 0x49, 0x64, 0x12, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e,
-	0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
-	0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x79, 0x49,
-	0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d,
-	0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
-	0x68, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
-	0x61, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6d, 0x0a,
-	0x0c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x2e,
-	0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e,
-	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61,
-	0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x70,
+	0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74,
+	0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x70, 0x0a, 0x0d, 0x53,
+	0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x65, 0x12, 0x2e, 0x2e, 0x70,
 	0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76,
-	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c,
-	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7b, 0x0a, 0x10,
-	0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61,
-	0x12, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65,
-	0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70,
-	0x6f, 0x73, 0x61, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
-	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50,
-	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x70, 0x0a, 0x0d, 0x53, 0x69, 0x6d,
-	0x75, 0x6c, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x64, 0x65, 0x12, 0x2e, 0x2e, 0x70, 0x65, 0x6e,
-	0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61,
-	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x54, 0x72,
-	0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x70, 0x65, 0x6e,
-	0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61,
-	0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x54, 0x72,
-	0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x08, 0x4b,
-	0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x29, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
-	0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c,
-	0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4b, 0x65,
-	0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6c,
-	0x0a, 0x0b, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x2e,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65,
+	0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x70,
+	0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76,
+	0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65,
+	0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a,
+	0x08, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x29, 0x2e, 0x70, 0x65, 0x6e, 0x75,
+	0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x31, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e,
+	0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
+	0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x6c, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12,
+	0x2c, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
+	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x66, 0x69,
+	0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e,
 	0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e,
 	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56,
-	0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x70, 0x65,
-	0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31,
-	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c,
-	0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x32, 0xb8, 0x05, 0x0a,
-	0x16, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x78, 0x79,
-	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x66, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x53, 0x74,
-	0x61, 0x74, 0x75, 0x73, 0x12, 0x2a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e,
-	0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e,
-	0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x2b, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65,
-	0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53,
-	0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
-	0x7b, 0x0a, 0x10, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x41, 0x73,
-	0x79, 0x6e, 0x63, 0x12, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
-	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42,
-	0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x41, 0x73, 0x79, 0x6e, 0x63, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72,
+	0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x32, 0xb8,
+	0x05, 0x0a, 0x16, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x50, 0x72, 0x6f,
+	0x78, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x66, 0x0a, 0x09, 0x47, 0x65, 0x74,
+	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72,
 	0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
-	0x31, 0x2e, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x41, 0x73, 0x79,
-	0x6e, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x78, 0x0a, 0x0f,
-	0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x53, 0x79, 0x6e, 0x63, 0x12,
-	0x30, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x72, 0x6f, 0x61, 0x64,
-	0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
+	0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c,
+	0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65,
+	0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x00, 0x12, 0x7b, 0x0a, 0x10, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78,
+	0x41, 0x73, 0x79, 0x6e, 0x63, 0x12, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61,
+	0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
+	0x2e, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x41, 0x73, 0x79, 0x6e,
+	0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d,
+	0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70,
+	0x68, 0x61, 0x31, 0x2e, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x41,
+	0x73, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x78,
+	0x0a, 0x0f, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x53, 0x79, 0x6e,
+	0x63, 0x12, 0x30, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
 	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x72, 0x6f,
-	0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x05, 0x47, 0x65, 0x74, 0x54, 0x78, 0x12,
-	0x26, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x78,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
-	0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x00, 0x12, 0x66, 0x0a, 0x09, 0x41, 0x42, 0x43, 0x49, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12,
-	0x2a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x42, 0x43, 0x49, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x70, 0x65,
-	0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31,
-	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x42, 0x43, 0x49, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7b, 0x0a, 0x10, 0x47, 0x65,
-	0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x31,
-	0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74,
-	0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f,
-	0x63, 0x6b, 0x42, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
+	0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
+	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42,
+	0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x54, 0x78, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x05, 0x47, 0x65, 0x74, 0x54,
+	0x78, 0x12, 0x26, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
 	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74,
-	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x85, 0x02, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e,
+	0x54, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x70, 0x65, 0x6e, 0x75,
+	0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c,
+	0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x09, 0x41, 0x42, 0x43, 0x49, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x12, 0x2a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69,
+	0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x42, 0x43,
+	0x49, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e,
 	0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e,
-	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74,
-	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x56, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2d, 0x7a, 0x6f, 0x6e,
-	0x65, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61,
-	0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0x3b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2,
-	0x02, 0x03, 0x50, 0x43, 0x58, 0xaa, 0x02, 0x18, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61,
-	0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31,
-	0xca, 0x02, 0x18, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6c, 0x69, 0x65,
-	0x6e, 0x74, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xe2, 0x02, 0x24, 0x50, 0x65,
-	0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31,
-	0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
-	0x74, 0x61, 0xea, 0x02, 0x1a, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x3a, 0x3a, 0x43,
-	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x41, 0x42, 0x43, 0x49, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7b, 0x0a, 0x10,
+	0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x12, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65,
+	0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x42,
+	0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63,
+	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47,
+	0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x85, 0x02, 0x0a, 0x1c, 0x63, 0x6f,
+	0x6d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
+	0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x0b, 0x43, 0x6c, 0x69, 0x65,
+	0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x56, 0x67, 0x69, 0x74, 0x68, 0x75,
+	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2d, 0x7a,
+	0x6f, 0x6e, 0x65, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62,
+	0x72, 0x61, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x31, 0x3b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0xa2, 0x02, 0x03, 0x50, 0x43, 0x58, 0xaa, 0x02, 0x18, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62,
+	0x72, 0x61, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68,
+	0x61, 0x31, 0xca, 0x02, 0x18, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6c,
+	0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xe2, 0x02, 0x24,
+	0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5c,
+	0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
+	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1a, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x3a,
+	0x3a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61,
+	0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -5016,7 +4891,7 @@ func file_penumbra_client_v1alpha1_client_proto_rawDescGZIP() []byte {
 	return file_penumbra_client_v1alpha1_client_proto_rawDescData
 }
 
-var file_penumbra_client_v1alpha1_client_proto_msgTypes = make([]protoimpl.MessageInfo, 71)
+var file_penumbra_client_v1alpha1_client_proto_msgTypes = make([]protoimpl.MessageInfo, 69)
 var file_penumbra_client_v1alpha1_client_proto_goTypes = []interface{}{
 	(*InfoRequest)(nil),                            // 0: penumbra.client.v1alpha1.InfoRequest
 	(*InfoResponse)(nil),                           // 1: penumbra.client.v1alpha1.InfoResponse
@@ -5036,209 +4911,203 @@ var file_penumbra_client_v1alpha1_client_proto_goTypes = []interface{}{
 	(*ValidatorPenaltyResponse)(nil),               // 15: penumbra.client.v1alpha1.ValidatorPenaltyResponse
 	(*CurrentValidatorRateRequest)(nil),            // 16: penumbra.client.v1alpha1.CurrentValidatorRateRequest
 	(*CurrentValidatorRateResponse)(nil),           // 17: penumbra.client.v1alpha1.CurrentValidatorRateResponse
-	(*NextValidatorRateRequest)(nil),               // 18: penumbra.client.v1alpha1.NextValidatorRateRequest
-	(*NextValidatorRateResponse)(nil),              // 19: penumbra.client.v1alpha1.NextValidatorRateResponse
-	(*BatchSwapOutputDataRequest)(nil),             // 20: penumbra.client.v1alpha1.BatchSwapOutputDataRequest
-	(*BatchSwapOutputDataResponse)(nil),            // 21: penumbra.client.v1alpha1.BatchSwapOutputDataResponse
-	(*SwapExecutionRequest)(nil),                   // 22: penumbra.client.v1alpha1.SwapExecutionRequest
-	(*SwapExecutionResponse)(nil),                  // 23: penumbra.client.v1alpha1.SwapExecutionResponse
-	(*ArbExecutionRequest)(nil),                    // 24: penumbra.client.v1alpha1.ArbExecutionRequest
-	(*ArbExecutionResponse)(nil),                   // 25: penumbra.client.v1alpha1.ArbExecutionResponse
-	(*SwapExecutionsRequest)(nil),                  // 26: penumbra.client.v1alpha1.SwapExecutionsRequest
-	(*SwapExecutionsResponse)(nil),                 // 27: penumbra.client.v1alpha1.SwapExecutionsResponse
-	(*ArbExecutionsRequest)(nil),                   // 28: penumbra.client.v1alpha1.ArbExecutionsRequest
-	(*ArbExecutionsResponse)(nil),                  // 29: penumbra.client.v1alpha1.ArbExecutionsResponse
-	(*LiquidityPositionsRequest)(nil),              // 30: penumbra.client.v1alpha1.LiquidityPositionsRequest
-	(*LiquidityPositionsResponse)(nil),             // 31: penumbra.client.v1alpha1.LiquidityPositionsResponse
-	(*LiquidityPositionsByPriceRequest)(nil),       // 32: penumbra.client.v1alpha1.LiquidityPositionsByPriceRequest
-	(*LiquidityPositionsByPriceResponse)(nil),      // 33: penumbra.client.v1alpha1.LiquidityPositionsByPriceResponse
-	(*LiquidityPositionByIdRequest)(nil),           // 34: penumbra.client.v1alpha1.LiquidityPositionByIdRequest
-	(*LiquidityPositionByIdResponse)(nil),          // 35: penumbra.client.v1alpha1.LiquidityPositionByIdResponse
-	(*LiquidityPositionsByIdRequest)(nil),          // 36: penumbra.client.v1alpha1.LiquidityPositionsByIdRequest
-	(*LiquidityPositionsByIdResponse)(nil),         // 37: penumbra.client.v1alpha1.LiquidityPositionsByIdResponse
-	(*SpreadRequest)(nil),                          // 38: penumbra.client.v1alpha1.SpreadRequest
-	(*SpreadResponse)(nil),                         // 39: penumbra.client.v1alpha1.SpreadResponse
-	(*DenomMetadataByIdRequest)(nil),               // 40: penumbra.client.v1alpha1.DenomMetadataByIdRequest
-	(*DenomMetadataByIdResponse)(nil),              // 41: penumbra.client.v1alpha1.DenomMetadataByIdResponse
-	(*ProposalInfoRequest)(nil),                    // 42: penumbra.client.v1alpha1.ProposalInfoRequest
-	(*ProposalInfoResponse)(nil),                   // 43: penumbra.client.v1alpha1.ProposalInfoResponse
-	(*ProposalRateDataRequest)(nil),                // 44: penumbra.client.v1alpha1.ProposalRateDataRequest
-	(*ProposalRateDataResponse)(nil),               // 45: penumbra.client.v1alpha1.ProposalRateDataResponse
-	(*SimulateTradeRequest)(nil),                   // 46: penumbra.client.v1alpha1.SimulateTradeRequest
-	(*SimulateTradeResponse)(nil),                  // 47: penumbra.client.v1alpha1.SimulateTradeResponse
-	(*KeyValueRequest)(nil),                        // 48: penumbra.client.v1alpha1.KeyValueRequest
-	(*KeyValueResponse)(nil),                       // 49: penumbra.client.v1alpha1.KeyValueResponse
-	(*PrefixValueRequest)(nil),                     // 50: penumbra.client.v1alpha1.PrefixValueRequest
-	(*PrefixValueResponse)(nil),                    // 51: penumbra.client.v1alpha1.PrefixValueResponse
-	(*GetTxRequest)(nil),                           // 52: penumbra.client.v1alpha1.GetTxRequest
-	(*GetTxResponse)(nil),                          // 53: penumbra.client.v1alpha1.GetTxResponse
-	(*TxResult)(nil),                               // 54: penumbra.client.v1alpha1.TxResult
-	(*Tag)(nil),                                    // 55: penumbra.client.v1alpha1.Tag
-	(*BroadcastTxAsyncRequest)(nil),                // 56: penumbra.client.v1alpha1.BroadcastTxAsyncRequest
-	(*BroadcastTxAsyncResponse)(nil),               // 57: penumbra.client.v1alpha1.BroadcastTxAsyncResponse
-	(*BroadcastTxSyncRequest)(nil),                 // 58: penumbra.client.v1alpha1.BroadcastTxSyncRequest
-	(*BroadcastTxSyncResponse)(nil),                // 59: penumbra.client.v1alpha1.BroadcastTxSyncResponse
-	(*GetStatusRequest)(nil),                       // 60: penumbra.client.v1alpha1.GetStatusRequest
-	(*GetStatusResponse)(nil),                      // 61: penumbra.client.v1alpha1.GetStatusResponse
-	(*SyncInfo)(nil),                               // 62: penumbra.client.v1alpha1.SyncInfo
-	(*ABCIQueryRequest)(nil),                       // 63: penumbra.client.v1alpha1.ABCIQueryRequest
-	(*ABCIQueryResponse)(nil),                      // 64: penumbra.client.v1alpha1.ABCIQueryResponse
-	(*GetBlockByHeightRequest)(nil),                // 65: penumbra.client.v1alpha1.GetBlockByHeightRequest
-	(*GetBlockByHeightResponse)(nil),               // 66: penumbra.client.v1alpha1.GetBlockByHeightResponse
-	(*SimulateTradeRequest_Routing)(nil),           // 67: penumbra.client.v1alpha1.SimulateTradeRequest.Routing
-	(*SimulateTradeRequest_Routing_SingleHop)(nil), // 68: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.SingleHop
-	(*SimulateTradeRequest_Routing_Default)(nil),   // 69: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.Default
-	(*KeyValueResponse_Value)(nil),                 // 70: penumbra.client.v1alpha1.KeyValueResponse.Value
-	(*v1alpha1.CompactBlock)(nil),                  // 71: penumbra.core.chain.v1alpha1.CompactBlock
-	(*v1alpha1.Epoch)(nil),                         // 72: penumbra.core.chain.v1alpha1.Epoch
-	(*v1alpha1.ChainParameters)(nil),               // 73: penumbra.core.chain.v1alpha1.ChainParameters
-	(*v1alpha11.ValidatorInfo)(nil),                // 74: penumbra.core.stake.v1alpha1.ValidatorInfo
-	(*v1alpha12.StateCommitment)(nil),              // 75: penumbra.core.crypto.v1alpha1.StateCommitment
-	(*v1alpha1.NoteSource)(nil),                    // 76: penumbra.core.chain.v1alpha1.NoteSource
-	(*v1alpha12.IdentityKey)(nil),                  // 77: penumbra.core.crypto.v1alpha1.IdentityKey
-	(*v1alpha11.ValidatorStatus)(nil),              // 78: penumbra.core.stake.v1alpha1.ValidatorStatus
-	(*v1alpha11.Penalty)(nil),                      // 79: penumbra.core.stake.v1alpha1.Penalty
-	(*v1alpha11.RateData)(nil),                     // 80: penumbra.core.stake.v1alpha1.RateData
-	(*v1alpha13.TradingPair)(nil),                  // 81: penumbra.core.dex.v1alpha1.TradingPair
-	(*v1alpha13.BatchSwapOutputData)(nil),          // 82: penumbra.core.dex.v1alpha1.BatchSwapOutputData
-	(*v1alpha13.DirectedTradingPair)(nil),          // 83: penumbra.core.dex.v1alpha1.DirectedTradingPair
-	(*v1alpha13.SwapExecution)(nil),                // 84: penumbra.core.dex.v1alpha1.SwapExecution
-	(*v1alpha13.Position)(nil),                     // 85: penumbra.core.dex.v1alpha1.Position
-	(*v1alpha13.PositionId)(nil),                   // 86: penumbra.core.dex.v1alpha1.PositionId
-	(*v1alpha12.AssetId)(nil),                      // 87: penumbra.core.crypto.v1alpha1.AssetId
-	(*v1alpha12.DenomMetadata)(nil),                // 88: penumbra.core.crypto.v1alpha1.DenomMetadata
-	(*v1alpha12.Value)(nil),                        // 89: penumbra.core.crypto.v1alpha1.Value
-	(*types.MerkleProof)(nil),                      // 90: ibc.core.commitment.v1.MerkleProof
-	(*p2p.DefaultNodeInfo)(nil),                    // 91: tendermint.p2p.DefaultNodeInfo
-	(*types1.Validator)(nil),                       // 92: tendermint.types.Validator
-	(*timestamppb.Timestamp)(nil),                  // 93: google.protobuf.Timestamp
-	(*crypto.ProofOps)(nil),                        // 94: tendermint.crypto.ProofOps
-	(*types1.BlockID)(nil),                         // 95: tendermint.types.BlockID
-	(*types1.Block)(nil),                           // 96: tendermint.types.Block
+	(*BatchSwapOutputDataRequest)(nil),             // 18: penumbra.client.v1alpha1.BatchSwapOutputDataRequest
+	(*BatchSwapOutputDataResponse)(nil),            // 19: penumbra.client.v1alpha1.BatchSwapOutputDataResponse
+	(*SwapExecutionRequest)(nil),                   // 20: penumbra.client.v1alpha1.SwapExecutionRequest
+	(*SwapExecutionResponse)(nil),                  // 21: penumbra.client.v1alpha1.SwapExecutionResponse
+	(*ArbExecutionRequest)(nil),                    // 22: penumbra.client.v1alpha1.ArbExecutionRequest
+	(*ArbExecutionResponse)(nil),                   // 23: penumbra.client.v1alpha1.ArbExecutionResponse
+	(*SwapExecutionsRequest)(nil),                  // 24: penumbra.client.v1alpha1.SwapExecutionsRequest
+	(*SwapExecutionsResponse)(nil),                 // 25: penumbra.client.v1alpha1.SwapExecutionsResponse
+	(*ArbExecutionsRequest)(nil),                   // 26: penumbra.client.v1alpha1.ArbExecutionsRequest
+	(*ArbExecutionsResponse)(nil),                  // 27: penumbra.client.v1alpha1.ArbExecutionsResponse
+	(*LiquidityPositionsRequest)(nil),              // 28: penumbra.client.v1alpha1.LiquidityPositionsRequest
+	(*LiquidityPositionsResponse)(nil),             // 29: penumbra.client.v1alpha1.LiquidityPositionsResponse
+	(*LiquidityPositionsByPriceRequest)(nil),       // 30: penumbra.client.v1alpha1.LiquidityPositionsByPriceRequest
+	(*LiquidityPositionsByPriceResponse)(nil),      // 31: penumbra.client.v1alpha1.LiquidityPositionsByPriceResponse
+	(*LiquidityPositionByIdRequest)(nil),           // 32: penumbra.client.v1alpha1.LiquidityPositionByIdRequest
+	(*LiquidityPositionByIdResponse)(nil),          // 33: penumbra.client.v1alpha1.LiquidityPositionByIdResponse
+	(*LiquidityPositionsByIdRequest)(nil),          // 34: penumbra.client.v1alpha1.LiquidityPositionsByIdRequest
+	(*LiquidityPositionsByIdResponse)(nil),         // 35: penumbra.client.v1alpha1.LiquidityPositionsByIdResponse
+	(*SpreadRequest)(nil),                          // 36: penumbra.client.v1alpha1.SpreadRequest
+	(*SpreadResponse)(nil),                         // 37: penumbra.client.v1alpha1.SpreadResponse
+	(*DenomMetadataByIdRequest)(nil),               // 38: penumbra.client.v1alpha1.DenomMetadataByIdRequest
+	(*DenomMetadataByIdResponse)(nil),              // 39: penumbra.client.v1alpha1.DenomMetadataByIdResponse
+	(*ProposalInfoRequest)(nil),                    // 40: penumbra.client.v1alpha1.ProposalInfoRequest
+	(*ProposalInfoResponse)(nil),                   // 41: penumbra.client.v1alpha1.ProposalInfoResponse
+	(*ProposalRateDataRequest)(nil),                // 42: penumbra.client.v1alpha1.ProposalRateDataRequest
+	(*ProposalRateDataResponse)(nil),               // 43: penumbra.client.v1alpha1.ProposalRateDataResponse
+	(*SimulateTradeRequest)(nil),                   // 44: penumbra.client.v1alpha1.SimulateTradeRequest
+	(*SimulateTradeResponse)(nil),                  // 45: penumbra.client.v1alpha1.SimulateTradeResponse
+	(*KeyValueRequest)(nil),                        // 46: penumbra.client.v1alpha1.KeyValueRequest
+	(*KeyValueResponse)(nil),                       // 47: penumbra.client.v1alpha1.KeyValueResponse
+	(*PrefixValueRequest)(nil),                     // 48: penumbra.client.v1alpha1.PrefixValueRequest
+	(*PrefixValueResponse)(nil),                    // 49: penumbra.client.v1alpha1.PrefixValueResponse
+	(*GetTxRequest)(nil),                           // 50: penumbra.client.v1alpha1.GetTxRequest
+	(*GetTxResponse)(nil),                          // 51: penumbra.client.v1alpha1.GetTxResponse
+	(*TxResult)(nil),                               // 52: penumbra.client.v1alpha1.TxResult
+	(*Tag)(nil),                                    // 53: penumbra.client.v1alpha1.Tag
+	(*BroadcastTxAsyncRequest)(nil),                // 54: penumbra.client.v1alpha1.BroadcastTxAsyncRequest
+	(*BroadcastTxAsyncResponse)(nil),               // 55: penumbra.client.v1alpha1.BroadcastTxAsyncResponse
+	(*BroadcastTxSyncRequest)(nil),                 // 56: penumbra.client.v1alpha1.BroadcastTxSyncRequest
+	(*BroadcastTxSyncResponse)(nil),                // 57: penumbra.client.v1alpha1.BroadcastTxSyncResponse
+	(*GetStatusRequest)(nil),                       // 58: penumbra.client.v1alpha1.GetStatusRequest
+	(*GetStatusResponse)(nil),                      // 59: penumbra.client.v1alpha1.GetStatusResponse
+	(*SyncInfo)(nil),                               // 60: penumbra.client.v1alpha1.SyncInfo
+	(*ABCIQueryRequest)(nil),                       // 61: penumbra.client.v1alpha1.ABCIQueryRequest
+	(*ABCIQueryResponse)(nil),                      // 62: penumbra.client.v1alpha1.ABCIQueryResponse
+	(*GetBlockByHeightRequest)(nil),                // 63: penumbra.client.v1alpha1.GetBlockByHeightRequest
+	(*GetBlockByHeightResponse)(nil),               // 64: penumbra.client.v1alpha1.GetBlockByHeightResponse
+	(*SimulateTradeRequest_Routing)(nil),           // 65: penumbra.client.v1alpha1.SimulateTradeRequest.Routing
+	(*SimulateTradeRequest_Routing_SingleHop)(nil), // 66: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.SingleHop
+	(*SimulateTradeRequest_Routing_Default)(nil),   // 67: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.Default
+	(*KeyValueResponse_Value)(nil),                 // 68: penumbra.client.v1alpha1.KeyValueResponse.Value
+	(*v1alpha1.CompactBlock)(nil),                  // 69: penumbra.core.chain.v1alpha1.CompactBlock
+	(*v1alpha1.Epoch)(nil),                         // 70: penumbra.core.chain.v1alpha1.Epoch
+	(*v1alpha1.ChainParameters)(nil),               // 71: penumbra.core.chain.v1alpha1.ChainParameters
+	(*v1alpha11.ValidatorInfo)(nil),                // 72: penumbra.core.stake.v1alpha1.ValidatorInfo
+	(*v1alpha12.StateCommitment)(nil),              // 73: penumbra.core.crypto.v1alpha1.StateCommitment
+	(*v1alpha1.NoteSource)(nil),                    // 74: penumbra.core.chain.v1alpha1.NoteSource
+	(*v1alpha12.IdentityKey)(nil),                  // 75: penumbra.core.crypto.v1alpha1.IdentityKey
+	(*v1alpha11.ValidatorStatus)(nil),              // 76: penumbra.core.stake.v1alpha1.ValidatorStatus
+	(*v1alpha11.Penalty)(nil),                      // 77: penumbra.core.stake.v1alpha1.Penalty
+	(*v1alpha11.RateData)(nil),                     // 78: penumbra.core.stake.v1alpha1.RateData
+	(*v1alpha13.TradingPair)(nil),                  // 79: penumbra.core.dex.v1alpha1.TradingPair
+	(*v1alpha13.BatchSwapOutputData)(nil),          // 80: penumbra.core.dex.v1alpha1.BatchSwapOutputData
+	(*v1alpha13.DirectedTradingPair)(nil),          // 81: penumbra.core.dex.v1alpha1.DirectedTradingPair
+	(*v1alpha13.SwapExecution)(nil),                // 82: penumbra.core.dex.v1alpha1.SwapExecution
+	(*v1alpha13.Position)(nil),                     // 83: penumbra.core.dex.v1alpha1.Position
+	(*v1alpha13.PositionId)(nil),                   // 84: penumbra.core.dex.v1alpha1.PositionId
+	(*v1alpha12.AssetId)(nil),                      // 85: penumbra.core.crypto.v1alpha1.AssetId
+	(*v1alpha12.DenomMetadata)(nil),                // 86: penumbra.core.crypto.v1alpha1.DenomMetadata
+	(*v1alpha12.Value)(nil),                        // 87: penumbra.core.crypto.v1alpha1.Value
+	(*types.MerkleProof)(nil),                      // 88: ibc.core.commitment.v1.MerkleProof
+	(*p2p.DefaultNodeInfo)(nil),                    // 89: tendermint.p2p.DefaultNodeInfo
+	(*types1.Validator)(nil),                       // 90: tendermint.types.Validator
+	(*timestamppb.Timestamp)(nil),                  // 91: google.protobuf.Timestamp
+	(*crypto.ProofOps)(nil),                        // 92: tendermint.crypto.ProofOps
+	(*types1.BlockID)(nil),                         // 93: tendermint.types.BlockID
+	(*types1.Block)(nil),                           // 94: tendermint.types.Block
 }
 var file_penumbra_client_v1alpha1_client_proto_depIdxs = []int32{
-	71, // 0: penumbra.client.v1alpha1.CompactBlockRangeResponse.compact_block:type_name -> penumbra.core.chain.v1alpha1.CompactBlock
-	72, // 1: penumbra.client.v1alpha1.EpochByHeightResponse.epoch:type_name -> penumbra.core.chain.v1alpha1.Epoch
-	73, // 2: penumbra.client.v1alpha1.ChainParametersResponse.chain_parameters:type_name -> penumbra.core.chain.v1alpha1.ChainParameters
-	74, // 3: penumbra.client.v1alpha1.ValidatorInfoResponse.validator_info:type_name -> penumbra.core.stake.v1alpha1.ValidatorInfo
-	75, // 4: penumbra.client.v1alpha1.TransactionByNoteRequest.note_commitment:type_name -> penumbra.core.crypto.v1alpha1.StateCommitment
-	76, // 5: penumbra.client.v1alpha1.TransactionByNoteResponse.note_source:type_name -> penumbra.core.chain.v1alpha1.NoteSource
-	77, // 6: penumbra.client.v1alpha1.ValidatorStatusRequest.identity_key:type_name -> penumbra.core.crypto.v1alpha1.IdentityKey
-	78, // 7: penumbra.client.v1alpha1.ValidatorStatusResponse.status:type_name -> penumbra.core.stake.v1alpha1.ValidatorStatus
-	77, // 8: penumbra.client.v1alpha1.ValidatorPenaltyRequest.identity_key:type_name -> penumbra.core.crypto.v1alpha1.IdentityKey
-	79, // 9: penumbra.client.v1alpha1.ValidatorPenaltyResponse.penalty:type_name -> penumbra.core.stake.v1alpha1.Penalty
-	77, // 10: penumbra.client.v1alpha1.CurrentValidatorRateRequest.identity_key:type_name -> penumbra.core.crypto.v1alpha1.IdentityKey
-	80, // 11: penumbra.client.v1alpha1.CurrentValidatorRateResponse.data:type_name -> penumbra.core.stake.v1alpha1.RateData
-	77, // 12: penumbra.client.v1alpha1.NextValidatorRateRequest.identity_key:type_name -> penumbra.core.crypto.v1alpha1.IdentityKey
-	80, // 13: penumbra.client.v1alpha1.NextValidatorRateResponse.data:type_name -> penumbra.core.stake.v1alpha1.RateData
-	81, // 14: penumbra.client.v1alpha1.BatchSwapOutputDataRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.TradingPair
-	82, // 15: penumbra.client.v1alpha1.BatchSwapOutputDataResponse.data:type_name -> penumbra.core.dex.v1alpha1.BatchSwapOutputData
-	83, // 16: penumbra.client.v1alpha1.SwapExecutionRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
-	84, // 17: penumbra.client.v1alpha1.SwapExecutionResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
-	84, // 18: penumbra.client.v1alpha1.ArbExecutionResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
-	83, // 19: penumbra.client.v1alpha1.SwapExecutionsRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
-	84, // 20: penumbra.client.v1alpha1.SwapExecutionsResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
-	83, // 21: penumbra.client.v1alpha1.SwapExecutionsResponse.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
-	84, // 22: penumbra.client.v1alpha1.ArbExecutionsResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
-	85, // 23: penumbra.client.v1alpha1.LiquidityPositionsResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
-	83, // 24: penumbra.client.v1alpha1.LiquidityPositionsByPriceRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
-	85, // 25: penumbra.client.v1alpha1.LiquidityPositionsByPriceResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
-	86, // 26: penumbra.client.v1alpha1.LiquidityPositionByIdRequest.position_id:type_name -> penumbra.core.dex.v1alpha1.PositionId
-	85, // 27: penumbra.client.v1alpha1.LiquidityPositionByIdResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
-	86, // 28: penumbra.client.v1alpha1.LiquidityPositionsByIdRequest.position_id:type_name -> penumbra.core.dex.v1alpha1.PositionId
-	85, // 29: penumbra.client.v1alpha1.LiquidityPositionsByIdResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
-	81, // 30: penumbra.client.v1alpha1.SpreadRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.TradingPair
-	85, // 31: penumbra.client.v1alpha1.SpreadResponse.best_1_to_2_position:type_name -> penumbra.core.dex.v1alpha1.Position
-	85, // 32: penumbra.client.v1alpha1.SpreadResponse.best_2_to_1_position:type_name -> penumbra.core.dex.v1alpha1.Position
-	87, // 33: penumbra.client.v1alpha1.DenomMetadataByIdRequest.asset_id:type_name -> penumbra.core.crypto.v1alpha1.AssetId
-	88, // 34: penumbra.client.v1alpha1.DenomMetadataByIdResponse.denom_metadata:type_name -> penumbra.core.crypto.v1alpha1.DenomMetadata
-	80, // 35: penumbra.client.v1alpha1.ProposalRateDataResponse.rate_data:type_name -> penumbra.core.stake.v1alpha1.RateData
-	89, // 36: penumbra.client.v1alpha1.SimulateTradeRequest.input:type_name -> penumbra.core.crypto.v1alpha1.Value
-	87, // 37: penumbra.client.v1alpha1.SimulateTradeRequest.output:type_name -> penumbra.core.crypto.v1alpha1.AssetId
-	67, // 38: penumbra.client.v1alpha1.SimulateTradeRequest.routing:type_name -> penumbra.client.v1alpha1.SimulateTradeRequest.Routing
-	84, // 39: penumbra.client.v1alpha1.SimulateTradeResponse.output:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
-	70, // 40: penumbra.client.v1alpha1.KeyValueResponse.value:type_name -> penumbra.client.v1alpha1.KeyValueResponse.Value
-	90, // 41: penumbra.client.v1alpha1.KeyValueResponse.proof:type_name -> ibc.core.commitment.v1.MerkleProof
-	54, // 42: penumbra.client.v1alpha1.GetTxResponse.tx_result:type_name -> penumbra.client.v1alpha1.TxResult
-	55, // 43: penumbra.client.v1alpha1.TxResult.tags:type_name -> penumbra.client.v1alpha1.Tag
-	91, // 44: penumbra.client.v1alpha1.GetStatusResponse.node_info:type_name -> tendermint.p2p.DefaultNodeInfo
-	62, // 45: penumbra.client.v1alpha1.GetStatusResponse.sync_info:type_name -> penumbra.client.v1alpha1.SyncInfo
-	92, // 46: penumbra.client.v1alpha1.GetStatusResponse.validator_info:type_name -> tendermint.types.Validator
-	93, // 47: penumbra.client.v1alpha1.SyncInfo.latest_block_time:type_name -> google.protobuf.Timestamp
-	94, // 48: penumbra.client.v1alpha1.ABCIQueryResponse.proof_ops:type_name -> tendermint.crypto.ProofOps
-	95, // 49: penumbra.client.v1alpha1.GetBlockByHeightResponse.block_id:type_name -> tendermint.types.BlockID
-	96, // 50: penumbra.client.v1alpha1.GetBlockByHeightResponse.block:type_name -> tendermint.types.Block
-	69, // 51: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.default:type_name -> penumbra.client.v1alpha1.SimulateTradeRequest.Routing.Default
-	68, // 52: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.single_hop:type_name -> penumbra.client.v1alpha1.SimulateTradeRequest.Routing.SingleHop
-	2,  // 53: penumbra.client.v1alpha1.ObliviousQueryService.CompactBlockRange:input_type -> penumbra.client.v1alpha1.CompactBlockRangeRequest
-	4,  // 54: penumbra.client.v1alpha1.ObliviousQueryService.ChainParameters:input_type -> penumbra.client.v1alpha1.ChainParametersRequest
-	5,  // 55: penumbra.client.v1alpha1.ObliviousQueryService.EpochByHeight:input_type -> penumbra.client.v1alpha1.EpochByHeightRequest
-	8,  // 56: penumbra.client.v1alpha1.ObliviousQueryService.ValidatorInfo:input_type -> penumbra.client.v1alpha1.ValidatorInfoRequest
-	0,  // 57: penumbra.client.v1alpha1.ObliviousQueryService.Info:input_type -> penumbra.client.v1alpha1.InfoRequest
-	10, // 58: penumbra.client.v1alpha1.SpecificQueryService.TransactionByNote:input_type -> penumbra.client.v1alpha1.TransactionByNoteRequest
-	12, // 59: penumbra.client.v1alpha1.SpecificQueryService.ValidatorStatus:input_type -> penumbra.client.v1alpha1.ValidatorStatusRequest
-	14, // 60: penumbra.client.v1alpha1.SpecificQueryService.ValidatorPenalty:input_type -> penumbra.client.v1alpha1.ValidatorPenaltyRequest
-	18, // 61: penumbra.client.v1alpha1.SpecificQueryService.NextValidatorRate:input_type -> penumbra.client.v1alpha1.NextValidatorRateRequest
-	16, // 62: penumbra.client.v1alpha1.SpecificQueryService.CurrentValidatorRate:input_type -> penumbra.client.v1alpha1.CurrentValidatorRateRequest
-	20, // 63: penumbra.client.v1alpha1.SpecificQueryService.BatchSwapOutputData:input_type -> penumbra.client.v1alpha1.BatchSwapOutputDataRequest
-	22, // 64: penumbra.client.v1alpha1.SpecificQueryService.SwapExecution:input_type -> penumbra.client.v1alpha1.SwapExecutionRequest
-	24, // 65: penumbra.client.v1alpha1.SpecificQueryService.ArbExecution:input_type -> penumbra.client.v1alpha1.ArbExecutionRequest
-	26, // 66: penumbra.client.v1alpha1.SpecificQueryService.SwapExecutions:input_type -> penumbra.client.v1alpha1.SwapExecutionsRequest
-	28, // 67: penumbra.client.v1alpha1.SpecificQueryService.ArbExecutions:input_type -> penumbra.client.v1alpha1.ArbExecutionsRequest
-	30, // 68: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositions:input_type -> penumbra.client.v1alpha1.LiquidityPositionsRequest
-	34, // 69: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionById:input_type -> penumbra.client.v1alpha1.LiquidityPositionByIdRequest
-	36, // 70: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsById:input_type -> penumbra.client.v1alpha1.LiquidityPositionsByIdRequest
-	32, // 71: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsByPrice:input_type -> penumbra.client.v1alpha1.LiquidityPositionsByPriceRequest
-	38, // 72: penumbra.client.v1alpha1.SpecificQueryService.Spread:input_type -> penumbra.client.v1alpha1.SpreadRequest
-	40, // 73: penumbra.client.v1alpha1.SpecificQueryService.DenomMetadataById:input_type -> penumbra.client.v1alpha1.DenomMetadataByIdRequest
-	42, // 74: penumbra.client.v1alpha1.SpecificQueryService.ProposalInfo:input_type -> penumbra.client.v1alpha1.ProposalInfoRequest
-	44, // 75: penumbra.client.v1alpha1.SpecificQueryService.ProposalRateData:input_type -> penumbra.client.v1alpha1.ProposalRateDataRequest
-	46, // 76: penumbra.client.v1alpha1.SpecificQueryService.SimulateTrade:input_type -> penumbra.client.v1alpha1.SimulateTradeRequest
-	48, // 77: penumbra.client.v1alpha1.SpecificQueryService.KeyValue:input_type -> penumbra.client.v1alpha1.KeyValueRequest
-	50, // 78: penumbra.client.v1alpha1.SpecificQueryService.PrefixValue:input_type -> penumbra.client.v1alpha1.PrefixValueRequest
-	60, // 79: penumbra.client.v1alpha1.TendermintProxyService.GetStatus:input_type -> penumbra.client.v1alpha1.GetStatusRequest
-	56, // 80: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxAsync:input_type -> penumbra.client.v1alpha1.BroadcastTxAsyncRequest
-	58, // 81: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxSync:input_type -> penumbra.client.v1alpha1.BroadcastTxSyncRequest
-	52, // 82: penumbra.client.v1alpha1.TendermintProxyService.GetTx:input_type -> penumbra.client.v1alpha1.GetTxRequest
-	63, // 83: penumbra.client.v1alpha1.TendermintProxyService.ABCIQuery:input_type -> penumbra.client.v1alpha1.ABCIQueryRequest
-	65, // 84: penumbra.client.v1alpha1.TendermintProxyService.GetBlockByHeight:input_type -> penumbra.client.v1alpha1.GetBlockByHeightRequest
-	3,  // 85: penumbra.client.v1alpha1.ObliviousQueryService.CompactBlockRange:output_type -> penumbra.client.v1alpha1.CompactBlockRangeResponse
-	7,  // 86: penumbra.client.v1alpha1.ObliviousQueryService.ChainParameters:output_type -> penumbra.client.v1alpha1.ChainParametersResponse
-	6,  // 87: penumbra.client.v1alpha1.ObliviousQueryService.EpochByHeight:output_type -> penumbra.client.v1alpha1.EpochByHeightResponse
-	9,  // 88: penumbra.client.v1alpha1.ObliviousQueryService.ValidatorInfo:output_type -> penumbra.client.v1alpha1.ValidatorInfoResponse
-	1,  // 89: penumbra.client.v1alpha1.ObliviousQueryService.Info:output_type -> penumbra.client.v1alpha1.InfoResponse
-	11, // 90: penumbra.client.v1alpha1.SpecificQueryService.TransactionByNote:output_type -> penumbra.client.v1alpha1.TransactionByNoteResponse
-	13, // 91: penumbra.client.v1alpha1.SpecificQueryService.ValidatorStatus:output_type -> penumbra.client.v1alpha1.ValidatorStatusResponse
-	15, // 92: penumbra.client.v1alpha1.SpecificQueryService.ValidatorPenalty:output_type -> penumbra.client.v1alpha1.ValidatorPenaltyResponse
-	19, // 93: penumbra.client.v1alpha1.SpecificQueryService.NextValidatorRate:output_type -> penumbra.client.v1alpha1.NextValidatorRateResponse
-	17, // 94: penumbra.client.v1alpha1.SpecificQueryService.CurrentValidatorRate:output_type -> penumbra.client.v1alpha1.CurrentValidatorRateResponse
-	21, // 95: penumbra.client.v1alpha1.SpecificQueryService.BatchSwapOutputData:output_type -> penumbra.client.v1alpha1.BatchSwapOutputDataResponse
-	23, // 96: penumbra.client.v1alpha1.SpecificQueryService.SwapExecution:output_type -> penumbra.client.v1alpha1.SwapExecutionResponse
-	25, // 97: penumbra.client.v1alpha1.SpecificQueryService.ArbExecution:output_type -> penumbra.client.v1alpha1.ArbExecutionResponse
-	27, // 98: penumbra.client.v1alpha1.SpecificQueryService.SwapExecutions:output_type -> penumbra.client.v1alpha1.SwapExecutionsResponse
-	29, // 99: penumbra.client.v1alpha1.SpecificQueryService.ArbExecutions:output_type -> penumbra.client.v1alpha1.ArbExecutionsResponse
-	31, // 100: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositions:output_type -> penumbra.client.v1alpha1.LiquidityPositionsResponse
-	35, // 101: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionById:output_type -> penumbra.client.v1alpha1.LiquidityPositionByIdResponse
-	37, // 102: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsById:output_type -> penumbra.client.v1alpha1.LiquidityPositionsByIdResponse
-	33, // 103: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsByPrice:output_type -> penumbra.client.v1alpha1.LiquidityPositionsByPriceResponse
-	39, // 104: penumbra.client.v1alpha1.SpecificQueryService.Spread:output_type -> penumbra.client.v1alpha1.SpreadResponse
-	41, // 105: penumbra.client.v1alpha1.SpecificQueryService.DenomMetadataById:output_type -> penumbra.client.v1alpha1.DenomMetadataByIdResponse
-	43, // 106: penumbra.client.v1alpha1.SpecificQueryService.ProposalInfo:output_type -> penumbra.client.v1alpha1.ProposalInfoResponse
-	45, // 107: penumbra.client.v1alpha1.SpecificQueryService.ProposalRateData:output_type -> penumbra.client.v1alpha1.ProposalRateDataResponse
-	47, // 108: penumbra.client.v1alpha1.SpecificQueryService.SimulateTrade:output_type -> penumbra.client.v1alpha1.SimulateTradeResponse
-	49, // 109: penumbra.client.v1alpha1.SpecificQueryService.KeyValue:output_type -> penumbra.client.v1alpha1.KeyValueResponse
-	51, // 110: penumbra.client.v1alpha1.SpecificQueryService.PrefixValue:output_type -> penumbra.client.v1alpha1.PrefixValueResponse
-	61, // 111: penumbra.client.v1alpha1.TendermintProxyService.GetStatus:output_type -> penumbra.client.v1alpha1.GetStatusResponse
-	57, // 112: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxAsync:output_type -> penumbra.client.v1alpha1.BroadcastTxAsyncResponse
-	59, // 113: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxSync:output_type -> penumbra.client.v1alpha1.BroadcastTxSyncResponse
-	53, // 114: penumbra.client.v1alpha1.TendermintProxyService.GetTx:output_type -> penumbra.client.v1alpha1.GetTxResponse
-	64, // 115: penumbra.client.v1alpha1.TendermintProxyService.ABCIQuery:output_type -> penumbra.client.v1alpha1.ABCIQueryResponse
-	66, // 116: penumbra.client.v1alpha1.TendermintProxyService.GetBlockByHeight:output_type -> penumbra.client.v1alpha1.GetBlockByHeightResponse
-	85, // [85:117] is the sub-list for method output_type
-	53, // [53:85] is the sub-list for method input_type
-	53, // [53:53] is the sub-list for extension type_name
-	53, // [53:53] is the sub-list for extension extendee
-	0,  // [0:53] is the sub-list for field type_name
+	69, // 0: penumbra.client.v1alpha1.CompactBlockRangeResponse.compact_block:type_name -> penumbra.core.chain.v1alpha1.CompactBlock
+	70, // 1: penumbra.client.v1alpha1.EpochByHeightResponse.epoch:type_name -> penumbra.core.chain.v1alpha1.Epoch
+	71, // 2: penumbra.client.v1alpha1.ChainParametersResponse.chain_parameters:type_name -> penumbra.core.chain.v1alpha1.ChainParameters
+	72, // 3: penumbra.client.v1alpha1.ValidatorInfoResponse.validator_info:type_name -> penumbra.core.stake.v1alpha1.ValidatorInfo
+	73, // 4: penumbra.client.v1alpha1.TransactionByNoteRequest.note_commitment:type_name -> penumbra.core.crypto.v1alpha1.StateCommitment
+	74, // 5: penumbra.client.v1alpha1.TransactionByNoteResponse.note_source:type_name -> penumbra.core.chain.v1alpha1.NoteSource
+	75, // 6: penumbra.client.v1alpha1.ValidatorStatusRequest.identity_key:type_name -> penumbra.core.crypto.v1alpha1.IdentityKey
+	76, // 7: penumbra.client.v1alpha1.ValidatorStatusResponse.status:type_name -> penumbra.core.stake.v1alpha1.ValidatorStatus
+	75, // 8: penumbra.client.v1alpha1.ValidatorPenaltyRequest.identity_key:type_name -> penumbra.core.crypto.v1alpha1.IdentityKey
+	77, // 9: penumbra.client.v1alpha1.ValidatorPenaltyResponse.penalty:type_name -> penumbra.core.stake.v1alpha1.Penalty
+	75, // 10: penumbra.client.v1alpha1.CurrentValidatorRateRequest.identity_key:type_name -> penumbra.core.crypto.v1alpha1.IdentityKey
+	78, // 11: penumbra.client.v1alpha1.CurrentValidatorRateResponse.data:type_name -> penumbra.core.stake.v1alpha1.RateData
+	79, // 12: penumbra.client.v1alpha1.BatchSwapOutputDataRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.TradingPair
+	80, // 13: penumbra.client.v1alpha1.BatchSwapOutputDataResponse.data:type_name -> penumbra.core.dex.v1alpha1.BatchSwapOutputData
+	81, // 14: penumbra.client.v1alpha1.SwapExecutionRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
+	82, // 15: penumbra.client.v1alpha1.SwapExecutionResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
+	82, // 16: penumbra.client.v1alpha1.ArbExecutionResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
+	81, // 17: penumbra.client.v1alpha1.SwapExecutionsRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
+	82, // 18: penumbra.client.v1alpha1.SwapExecutionsResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
+	81, // 19: penumbra.client.v1alpha1.SwapExecutionsResponse.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
+	82, // 20: penumbra.client.v1alpha1.ArbExecutionsResponse.swap_execution:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
+	83, // 21: penumbra.client.v1alpha1.LiquidityPositionsResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
+	81, // 22: penumbra.client.v1alpha1.LiquidityPositionsByPriceRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.DirectedTradingPair
+	83, // 23: penumbra.client.v1alpha1.LiquidityPositionsByPriceResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
+	84, // 24: penumbra.client.v1alpha1.LiquidityPositionByIdRequest.position_id:type_name -> penumbra.core.dex.v1alpha1.PositionId
+	83, // 25: penumbra.client.v1alpha1.LiquidityPositionByIdResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
+	84, // 26: penumbra.client.v1alpha1.LiquidityPositionsByIdRequest.position_id:type_name -> penumbra.core.dex.v1alpha1.PositionId
+	83, // 27: penumbra.client.v1alpha1.LiquidityPositionsByIdResponse.data:type_name -> penumbra.core.dex.v1alpha1.Position
+	79, // 28: penumbra.client.v1alpha1.SpreadRequest.trading_pair:type_name -> penumbra.core.dex.v1alpha1.TradingPair
+	83, // 29: penumbra.client.v1alpha1.SpreadResponse.best_1_to_2_position:type_name -> penumbra.core.dex.v1alpha1.Position
+	83, // 30: penumbra.client.v1alpha1.SpreadResponse.best_2_to_1_position:type_name -> penumbra.core.dex.v1alpha1.Position
+	85, // 31: penumbra.client.v1alpha1.DenomMetadataByIdRequest.asset_id:type_name -> penumbra.core.crypto.v1alpha1.AssetId
+	86, // 32: penumbra.client.v1alpha1.DenomMetadataByIdResponse.denom_metadata:type_name -> penumbra.core.crypto.v1alpha1.DenomMetadata
+	78, // 33: penumbra.client.v1alpha1.ProposalRateDataResponse.rate_data:type_name -> penumbra.core.stake.v1alpha1.RateData
+	87, // 34: penumbra.client.v1alpha1.SimulateTradeRequest.input:type_name -> penumbra.core.crypto.v1alpha1.Value
+	85, // 35: penumbra.client.v1alpha1.SimulateTradeRequest.output:type_name -> penumbra.core.crypto.v1alpha1.AssetId
+	65, // 36: penumbra.client.v1alpha1.SimulateTradeRequest.routing:type_name -> penumbra.client.v1alpha1.SimulateTradeRequest.Routing
+	82, // 37: penumbra.client.v1alpha1.SimulateTradeResponse.output:type_name -> penumbra.core.dex.v1alpha1.SwapExecution
+	68, // 38: penumbra.client.v1alpha1.KeyValueResponse.value:type_name -> penumbra.client.v1alpha1.KeyValueResponse.Value
+	88, // 39: penumbra.client.v1alpha1.KeyValueResponse.proof:type_name -> ibc.core.commitment.v1.MerkleProof
+	52, // 40: penumbra.client.v1alpha1.GetTxResponse.tx_result:type_name -> penumbra.client.v1alpha1.TxResult
+	53, // 41: penumbra.client.v1alpha1.TxResult.tags:type_name -> penumbra.client.v1alpha1.Tag
+	89, // 42: penumbra.client.v1alpha1.GetStatusResponse.node_info:type_name -> tendermint.p2p.DefaultNodeInfo
+	60, // 43: penumbra.client.v1alpha1.GetStatusResponse.sync_info:type_name -> penumbra.client.v1alpha1.SyncInfo
+	90, // 44: penumbra.client.v1alpha1.GetStatusResponse.validator_info:type_name -> tendermint.types.Validator
+	91, // 45: penumbra.client.v1alpha1.SyncInfo.latest_block_time:type_name -> google.protobuf.Timestamp
+	92, // 46: penumbra.client.v1alpha1.ABCIQueryResponse.proof_ops:type_name -> tendermint.crypto.ProofOps
+	93, // 47: penumbra.client.v1alpha1.GetBlockByHeightResponse.block_id:type_name -> tendermint.types.BlockID
+	94, // 48: penumbra.client.v1alpha1.GetBlockByHeightResponse.block:type_name -> tendermint.types.Block
+	67, // 49: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.default:type_name -> penumbra.client.v1alpha1.SimulateTradeRequest.Routing.Default
+	66, // 50: penumbra.client.v1alpha1.SimulateTradeRequest.Routing.single_hop:type_name -> penumbra.client.v1alpha1.SimulateTradeRequest.Routing.SingleHop
+	2,  // 51: penumbra.client.v1alpha1.ObliviousQueryService.CompactBlockRange:input_type -> penumbra.client.v1alpha1.CompactBlockRangeRequest
+	4,  // 52: penumbra.client.v1alpha1.ObliviousQueryService.ChainParameters:input_type -> penumbra.client.v1alpha1.ChainParametersRequest
+	5,  // 53: penumbra.client.v1alpha1.ObliviousQueryService.EpochByHeight:input_type -> penumbra.client.v1alpha1.EpochByHeightRequest
+	8,  // 54: penumbra.client.v1alpha1.ObliviousQueryService.ValidatorInfo:input_type -> penumbra.client.v1alpha1.ValidatorInfoRequest
+	0,  // 55: penumbra.client.v1alpha1.ObliviousQueryService.Info:input_type -> penumbra.client.v1alpha1.InfoRequest
+	10, // 56: penumbra.client.v1alpha1.SpecificQueryService.TransactionByNote:input_type -> penumbra.client.v1alpha1.TransactionByNoteRequest
+	12, // 57: penumbra.client.v1alpha1.SpecificQueryService.ValidatorStatus:input_type -> penumbra.client.v1alpha1.ValidatorStatusRequest
+	14, // 58: penumbra.client.v1alpha1.SpecificQueryService.ValidatorPenalty:input_type -> penumbra.client.v1alpha1.ValidatorPenaltyRequest
+	16, // 59: penumbra.client.v1alpha1.SpecificQueryService.CurrentValidatorRate:input_type -> penumbra.client.v1alpha1.CurrentValidatorRateRequest
+	18, // 60: penumbra.client.v1alpha1.SpecificQueryService.BatchSwapOutputData:input_type -> penumbra.client.v1alpha1.BatchSwapOutputDataRequest
+	20, // 61: penumbra.client.v1alpha1.SpecificQueryService.SwapExecution:input_type -> penumbra.client.v1alpha1.SwapExecutionRequest
+	22, // 62: penumbra.client.v1alpha1.SpecificQueryService.ArbExecution:input_type -> penumbra.client.v1alpha1.ArbExecutionRequest
+	24, // 63: penumbra.client.v1alpha1.SpecificQueryService.SwapExecutions:input_type -> penumbra.client.v1alpha1.SwapExecutionsRequest
+	26, // 64: penumbra.client.v1alpha1.SpecificQueryService.ArbExecutions:input_type -> penumbra.client.v1alpha1.ArbExecutionsRequest
+	28, // 65: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositions:input_type -> penumbra.client.v1alpha1.LiquidityPositionsRequest
+	32, // 66: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionById:input_type -> penumbra.client.v1alpha1.LiquidityPositionByIdRequest
+	34, // 67: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsById:input_type -> penumbra.client.v1alpha1.LiquidityPositionsByIdRequest
+	30, // 68: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsByPrice:input_type -> penumbra.client.v1alpha1.LiquidityPositionsByPriceRequest
+	36, // 69: penumbra.client.v1alpha1.SpecificQueryService.Spread:input_type -> penumbra.client.v1alpha1.SpreadRequest
+	38, // 70: penumbra.client.v1alpha1.SpecificQueryService.DenomMetadataById:input_type -> penumbra.client.v1alpha1.DenomMetadataByIdRequest
+	40, // 71: penumbra.client.v1alpha1.SpecificQueryService.ProposalInfo:input_type -> penumbra.client.v1alpha1.ProposalInfoRequest
+	42, // 72: penumbra.client.v1alpha1.SpecificQueryService.ProposalRateData:input_type -> penumbra.client.v1alpha1.ProposalRateDataRequest
+	44, // 73: penumbra.client.v1alpha1.SpecificQueryService.SimulateTrade:input_type -> penumbra.client.v1alpha1.SimulateTradeRequest
+	46, // 74: penumbra.client.v1alpha1.SpecificQueryService.KeyValue:input_type -> penumbra.client.v1alpha1.KeyValueRequest
+	48, // 75: penumbra.client.v1alpha1.SpecificQueryService.PrefixValue:input_type -> penumbra.client.v1alpha1.PrefixValueRequest
+	58, // 76: penumbra.client.v1alpha1.TendermintProxyService.GetStatus:input_type -> penumbra.client.v1alpha1.GetStatusRequest
+	54, // 77: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxAsync:input_type -> penumbra.client.v1alpha1.BroadcastTxAsyncRequest
+	56, // 78: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxSync:input_type -> penumbra.client.v1alpha1.BroadcastTxSyncRequest
+	50, // 79: penumbra.client.v1alpha1.TendermintProxyService.GetTx:input_type -> penumbra.client.v1alpha1.GetTxRequest
+	61, // 80: penumbra.client.v1alpha1.TendermintProxyService.ABCIQuery:input_type -> penumbra.client.v1alpha1.ABCIQueryRequest
+	63, // 81: penumbra.client.v1alpha1.TendermintProxyService.GetBlockByHeight:input_type -> penumbra.client.v1alpha1.GetBlockByHeightRequest
+	3,  // 82: penumbra.client.v1alpha1.ObliviousQueryService.CompactBlockRange:output_type -> penumbra.client.v1alpha1.CompactBlockRangeResponse
+	7,  // 83: penumbra.client.v1alpha1.ObliviousQueryService.ChainParameters:output_type -> penumbra.client.v1alpha1.ChainParametersResponse
+	6,  // 84: penumbra.client.v1alpha1.ObliviousQueryService.EpochByHeight:output_type -> penumbra.client.v1alpha1.EpochByHeightResponse
+	9,  // 85: penumbra.client.v1alpha1.ObliviousQueryService.ValidatorInfo:output_type -> penumbra.client.v1alpha1.ValidatorInfoResponse
+	1,  // 86: penumbra.client.v1alpha1.ObliviousQueryService.Info:output_type -> penumbra.client.v1alpha1.InfoResponse
+	11, // 87: penumbra.client.v1alpha1.SpecificQueryService.TransactionByNote:output_type -> penumbra.client.v1alpha1.TransactionByNoteResponse
+	13, // 88: penumbra.client.v1alpha1.SpecificQueryService.ValidatorStatus:output_type -> penumbra.client.v1alpha1.ValidatorStatusResponse
+	15, // 89: penumbra.client.v1alpha1.SpecificQueryService.ValidatorPenalty:output_type -> penumbra.client.v1alpha1.ValidatorPenaltyResponse
+	17, // 90: penumbra.client.v1alpha1.SpecificQueryService.CurrentValidatorRate:output_type -> penumbra.client.v1alpha1.CurrentValidatorRateResponse
+	19, // 91: penumbra.client.v1alpha1.SpecificQueryService.BatchSwapOutputData:output_type -> penumbra.client.v1alpha1.BatchSwapOutputDataResponse
+	21, // 92: penumbra.client.v1alpha1.SpecificQueryService.SwapExecution:output_type -> penumbra.client.v1alpha1.SwapExecutionResponse
+	23, // 93: penumbra.client.v1alpha1.SpecificQueryService.ArbExecution:output_type -> penumbra.client.v1alpha1.ArbExecutionResponse
+	25, // 94: penumbra.client.v1alpha1.SpecificQueryService.SwapExecutions:output_type -> penumbra.client.v1alpha1.SwapExecutionsResponse
+	27, // 95: penumbra.client.v1alpha1.SpecificQueryService.ArbExecutions:output_type -> penumbra.client.v1alpha1.ArbExecutionsResponse
+	29, // 96: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositions:output_type -> penumbra.client.v1alpha1.LiquidityPositionsResponse
+	33, // 97: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionById:output_type -> penumbra.client.v1alpha1.LiquidityPositionByIdResponse
+	35, // 98: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsById:output_type -> penumbra.client.v1alpha1.LiquidityPositionsByIdResponse
+	31, // 99: penumbra.client.v1alpha1.SpecificQueryService.LiquidityPositionsByPrice:output_type -> penumbra.client.v1alpha1.LiquidityPositionsByPriceResponse
+	37, // 100: penumbra.client.v1alpha1.SpecificQueryService.Spread:output_type -> penumbra.client.v1alpha1.SpreadResponse
+	39, // 101: penumbra.client.v1alpha1.SpecificQueryService.DenomMetadataById:output_type -> penumbra.client.v1alpha1.DenomMetadataByIdResponse
+	41, // 102: penumbra.client.v1alpha1.SpecificQueryService.ProposalInfo:output_type -> penumbra.client.v1alpha1.ProposalInfoResponse
+	43, // 103: penumbra.client.v1alpha1.SpecificQueryService.ProposalRateData:output_type -> penumbra.client.v1alpha1.ProposalRateDataResponse
+	45, // 104: penumbra.client.v1alpha1.SpecificQueryService.SimulateTrade:output_type -> penumbra.client.v1alpha1.SimulateTradeResponse
+	47, // 105: penumbra.client.v1alpha1.SpecificQueryService.KeyValue:output_type -> penumbra.client.v1alpha1.KeyValueResponse
+	49, // 106: penumbra.client.v1alpha1.SpecificQueryService.PrefixValue:output_type -> penumbra.client.v1alpha1.PrefixValueResponse
+	59, // 107: penumbra.client.v1alpha1.TendermintProxyService.GetStatus:output_type -> penumbra.client.v1alpha1.GetStatusResponse
+	55, // 108: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxAsync:output_type -> penumbra.client.v1alpha1.BroadcastTxAsyncResponse
+	57, // 109: penumbra.client.v1alpha1.TendermintProxyService.BroadcastTxSync:output_type -> penumbra.client.v1alpha1.BroadcastTxSyncResponse
+	51, // 110: penumbra.client.v1alpha1.TendermintProxyService.GetTx:output_type -> penumbra.client.v1alpha1.GetTxResponse
+	62, // 111: penumbra.client.v1alpha1.TendermintProxyService.ABCIQuery:output_type -> penumbra.client.v1alpha1.ABCIQueryResponse
+	64, // 112: penumbra.client.v1alpha1.TendermintProxyService.GetBlockByHeight:output_type -> penumbra.client.v1alpha1.GetBlockByHeightResponse
+	82, // [82:113] is the sub-list for method output_type
+	51, // [51:82] is the sub-list for method input_type
+	51, // [51:51] is the sub-list for extension type_name
+	51, // [51:51] is the sub-list for extension extendee
+	0,  // [0:51] is the sub-list for field type_name
 }
 
 func init() { file_penumbra_client_v1alpha1_client_proto_init() }
@@ -5464,30 +5333,6 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 			}
 		}
 		file_penumbra_client_v1alpha1_client_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*NextValidatorRateRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*NextValidatorRateResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BatchSwapOutputDataRequest); i {
 			case 0:
 				return &v.state
@@ -5499,7 +5344,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BatchSwapOutputDataResponse); i {
 			case 0:
 				return &v.state
@@ -5511,7 +5356,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SwapExecutionRequest); i {
 			case 0:
 				return &v.state
@@ -5523,7 +5368,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SwapExecutionResponse); i {
 			case 0:
 				return &v.state
@@ -5535,7 +5380,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ArbExecutionRequest); i {
 			case 0:
 				return &v.state
@@ -5547,7 +5392,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ArbExecutionResponse); i {
 			case 0:
 				return &v.state
@@ -5559,7 +5404,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SwapExecutionsRequest); i {
 			case 0:
 				return &v.state
@@ -5571,7 +5416,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SwapExecutionsResponse); i {
 			case 0:
 				return &v.state
@@ -5583,7 +5428,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ArbExecutionsRequest); i {
 			case 0:
 				return &v.state
@@ -5595,7 +5440,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ArbExecutionsResponse); i {
 			case 0:
 				return &v.state
@@ -5607,7 +5452,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionsRequest); i {
 			case 0:
 				return &v.state
@@ -5619,7 +5464,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionsResponse); i {
 			case 0:
 				return &v.state
@@ -5631,7 +5476,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionsByPriceRequest); i {
 			case 0:
 				return &v.state
@@ -5643,7 +5488,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionsByPriceResponse); i {
 			case 0:
 				return &v.state
@@ -5655,7 +5500,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionByIdRequest); i {
 			case 0:
 				return &v.state
@@ -5667,7 +5512,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionByIdResponse); i {
 			case 0:
 				return &v.state
@@ -5679,7 +5524,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionsByIdRequest); i {
 			case 0:
 				return &v.state
@@ -5691,7 +5536,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*LiquidityPositionsByIdResponse); i {
 			case 0:
 				return &v.state
@@ -5703,7 +5548,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SpreadRequest); i {
 			case 0:
 				return &v.state
@@ -5715,7 +5560,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SpreadResponse); i {
 			case 0:
 				return &v.state
@@ -5727,7 +5572,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DenomMetadataByIdRequest); i {
 			case 0:
 				return &v.state
@@ -5739,7 +5584,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DenomMetadataByIdResponse); i {
 			case 0:
 				return &v.state
@@ -5751,7 +5596,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ProposalInfoRequest); i {
 			case 0:
 				return &v.state
@@ -5763,7 +5608,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ProposalInfoResponse); i {
 			case 0:
 				return &v.state
@@ -5775,7 +5620,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ProposalRateDataRequest); i {
 			case 0:
 				return &v.state
@@ -5787,7 +5632,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ProposalRateDataResponse); i {
 			case 0:
 				return &v.state
@@ -5799,7 +5644,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SimulateTradeRequest); i {
 			case 0:
 				return &v.state
@@ -5811,7 +5656,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SimulateTradeResponse); i {
 			case 0:
 				return &v.state
@@ -5823,7 +5668,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*KeyValueRequest); i {
 			case 0:
 				return &v.state
@@ -5835,7 +5680,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*KeyValueResponse); i {
 			case 0:
 				return &v.state
@@ -5847,7 +5692,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*PrefixValueRequest); i {
 			case 0:
 				return &v.state
@@ -5859,7 +5704,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*PrefixValueResponse); i {
 			case 0:
 				return &v.state
@@ -5871,7 +5716,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetTxRequest); i {
 			case 0:
 				return &v.state
@@ -5883,7 +5728,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetTxResponse); i {
 			case 0:
 				return &v.state
@@ -5895,7 +5740,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*TxResult); i {
 			case 0:
 				return &v.state
@@ -5907,7 +5752,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*Tag); i {
 			case 0:
 				return &v.state
@@ -5919,7 +5764,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BroadcastTxAsyncRequest); i {
 			case 0:
 				return &v.state
@@ -5931,7 +5776,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BroadcastTxAsyncResponse); i {
 			case 0:
 				return &v.state
@@ -5943,7 +5788,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BroadcastTxSyncRequest); i {
 			case 0:
 				return &v.state
@@ -5955,7 +5800,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*BroadcastTxSyncResponse); i {
 			case 0:
 				return &v.state
@@ -5967,7 +5812,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetStatusRequest); i {
 			case 0:
 				return &v.state
@@ -5979,7 +5824,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetStatusResponse); i {
 			case 0:
 				return &v.state
@@ -5991,7 +5836,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SyncInfo); i {
 			case 0:
 				return &v.state
@@ -6003,7 +5848,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ABCIQueryRequest); i {
 			case 0:
 				return &v.state
@@ -6015,7 +5860,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ABCIQueryResponse); i {
 			case 0:
 				return &v.state
@@ -6027,7 +5872,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetBlockByHeightRequest); i {
 			case 0:
 				return &v.state
@@ -6039,7 +5884,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetBlockByHeightResponse); i {
 			case 0:
 				return &v.state
@@ -6051,7 +5896,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SimulateTradeRequest_Routing); i {
 			case 0:
 				return &v.state
@@ -6063,7 +5908,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SimulateTradeRequest_Routing_SingleHop); i {
 			case 0:
 				return &v.state
@@ -6075,7 +5920,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SimulateTradeRequest_Routing_Default); i {
 			case 0:
 				return &v.state
@@ -6087,7 +5932,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 				return nil
 			}
 		}
-		file_penumbra_client_v1alpha1_client_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} {
+		file_penumbra_client_v1alpha1_client_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*KeyValueResponse_Value); i {
 			case 0:
 				return &v.state
@@ -6100,7 +5945,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 			}
 		}
 	}
-	file_penumbra_client_v1alpha1_client_proto_msgTypes[67].OneofWrappers = []interface{}{
+	file_penumbra_client_v1alpha1_client_proto_msgTypes[65].OneofWrappers = []interface{}{
 		(*SimulateTradeRequest_Routing_Default_)(nil),
 		(*SimulateTradeRequest_Routing_SingleHop_)(nil),
 	}
@@ -6110,7 +5955,7 @@ func file_penumbra_client_v1alpha1_client_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_penumbra_client_v1alpha1_client_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   71,
+			NumMessages:   69,
 			NumExtensions: 0,
 			NumServices:   3,
 		},
diff --git a/proto/penumbra/penumbra/client/v1alpha1/client.proto b/proto/penumbra/penumbra/client/v1alpha1/client.proto
index 1df1780395..ad564a6260 100644
--- a/proto/penumbra/penumbra/client/v1alpha1/client.proto
+++ b/proto/penumbra/penumbra/client/v1alpha1/client.proto
@@ -113,7 +113,6 @@ service SpecificQueryService {
   rpc TransactionByNote(TransactionByNoteRequest) returns (TransactionByNoteResponse);
   rpc ValidatorStatus(ValidatorStatusRequest) returns (ValidatorStatusResponse);
   rpc ValidatorPenalty(ValidatorPenaltyRequest) returns (ValidatorPenaltyResponse);
-  rpc NextValidatorRate(NextValidatorRateRequest) returns (NextValidatorRateResponse);
   rpc CurrentValidatorRate(CurrentValidatorRateRequest) returns (CurrentValidatorRateResponse);
 
   rpc BatchSwapOutputData(BatchSwapOutputDataRequest) returns (BatchSwapOutputDataResponse);
@@ -194,16 +193,6 @@ message CurrentValidatorRateResponse {
   core.stake.v1alpha1.RateData data = 1;
 }
 
-message NextValidatorRateRequest {
-  // The expected chain id (empty string if no expectation).
-  string chain_id = 1;
-  core.crypto.v1alpha1.IdentityKey identity_key = 2;
-}
-
-message NextValidatorRateResponse {
-  core.stake.v1alpha1.RateData data = 1;
-}
-
 // Requests batch swap data associated with a given height and trading pair from the view service.
 message BatchSwapOutputDataRequest {
   // The expected chain id (empty string if no expectation).