feat(pcli): support lqt votes by subaccount (#5244)

## Describe your changes
Previously the `pcli tx lqt-vote` command only inspected subaccount 0
when searching for delegation notes to use in voting. If a user stores
their delegations in a different subaccounts, it wasn't possible to vote
with them. Here we allow a user to opt in to voting in the LQT via a
specific subaccount, provided as `--source n`, the same CLI used for
`pcli tx send`.

## Issue ticket number and link

n/a

## Testing and review

Visual review of the diff should be sufficient, as the logic is
straightforward.

## Checklist before requesting a review

- [x] I have added guiding text to explain how a reviewer should test
these changes.

- [x] If this code contains consensus-breaking changes, I have added the
"consensus-breaking" label. Otherwise, I declare my belief that there
are not consensus-breaking changes, for the following reason:

  > only changes client-side tooling, no changes to app consensus logic

---------

Signed-off-by: Lúcás Meier <cronokirby@gmail.com>
Co-authored-by: Lúcás Meier <lucas@cronokirby.com>

Author: conorsch

crates/bin/pcli/src/command/tx/lqt_vote.rs

@@ -1,7 +1,7 @@
 use anyhow::anyhow;
 use penumbra_sdk_asset::asset::REGISTRY;
 use penumbra_sdk_fee::{FeeTier, GasPrices};
-use penumbra_sdk_keys::Address;
+use penumbra_sdk_keys::{keys::AddressIndex, Address};
 use penumbra_sdk_proto::core::component::sct::v1::{
     query_service_client::QueryServiceClient as SctQueryServiceClient, EpochByHeightRequest,
 };
@@ -38,6 +38,9 @@ pub struct LqtVoteCmd {
     /// This can also be an integer, indicating an ephemeral address of a sub-account.
     #[clap(short, long)]
     rewards_recipient: Option<String>,
+    /// Only consider delegations within the specified subaccount.
+    #[clap(long, default_value = "0", display_order = 300)]
+    source: u32,
     /// The selected fee tier.
     #[clap(short, long, default_value_t)]
     fee_tier: FeeTier,
@@ -79,7 +82,17 @@ impl LqtVoteCmd {
         let vote_denom = vote_meta.base_denom();
 
         let epoch = fetch_epoch(app).await?;
-        let voting_notes = app.view().lqt_voting_notes(epoch.index, None).await?;
+        let voting_notes = app
+            .view()
+            .lqt_voting_notes(epoch.index, Some(AddressIndex::new(self.source)))
+            .await?;
+
+        if voting_notes.is_empty() {
+            anyhow::bail!(
+                "no voting notes found in subaccount {}, cannot cast LQT vote",
+                self.source
+            );
+        }
 
         let mut planner = Planner::new(OsRng);
 
@@ -106,11 +119,13 @@ impl LqtVoteCmd {
         let change_addr = app
             .config
             .full_viewing_key
-            .ephemeral_address(OsRng, Default::default())
+            .ephemeral_address(OsRng, AddressIndex::new(self.source))
             .0;
         planner.change_address(change_addr.clone());
 
-        let plan = planner.plan(app.view(), Default::default()).await?;
+        let plan = planner
+            .plan(app.view(), AddressIndex::new(self.source))
+            .await?;
         app.build_and_submit_transaction(plan).await?;
 
         Ok(())

crates/view/src/storage.rs

@@ -988,17 +988,15 @@ impl Storage {
         .await?
     }
 
+    /// Return all notes that are eligible for voting at `votable_at_height`.
+    /// If an `address_index` is provided, only notes from within that subaccount
+    /// will be returned; otherwise, all voting notes across all subaccounts will
+    /// returned. If you want just the main account, then set `Some(0)` in the caller.
     pub async fn notes_for_voting(
         &self,
         address_index: Option<penumbra_sdk_keys::keys::AddressIndex>,
         votable_at_height: u64,
     ) -> anyhow::Result<Vec<(SpendableNoteRecord, IdentityKey)>> {
-        // If set, only return notes with the specified address index.
-        // crypto.AddressIndex address_index = 3;
-        let address_clause = address_index
-            .map(|d| format!("x'{}'", hex::encode(d.to_bytes())))
-            .unwrap_or_else(|| "address_index".to_string());
-
         let pool = self.pool.clone();
 
         spawn_blocking(move || {
@@ -1021,8 +1019,7 @@ impl Storage {
                     FROM
                         notes JOIN spendable_notes ON notes.note_commitment = spendable_notes.note_commitment
                     WHERE
-                        spendable_notes.address_index IS {address_clause}
-                        AND notes.asset_id IN (
+                        notes.asset_id IN (
                             SELECT asset_id FROM assets WHERE denom LIKE '_delegation\\_%' ESCAPE '\\'
                         )
                         AND ((spendable_notes.height_spent IS NULL) OR (spendable_notes.height_spent > {votable_at_height}))
@@ -1036,6 +1033,10 @@ impl Storage {
             // do it this way; if it becomes slow, we can do it better
             let mut results = Vec::new();
             for record in spendable_note_records {
+                // Skip notes that don't match the account index, if declared.
+                if matches!(address_index, Some(a) if a.account != record.address_index.account) {
+                      continue;
+                }
                 let asset_id = record.note.asset_id().to_bytes().to_vec();
                 let denom: String = dbtx.query_row_and_then(
                     "SELECT denom FROM assets WHERE asset_id = ?1",