Add Ironwood wallet migration and policy

Author: czarcas7ic

zcash_client_backend/CHANGELOG.md

@@ -17,6 +17,11 @@ workspace.
 - Ironwood scanning and tree APIs: `BlockMetadata::ironwood_tree_size`,
   `NoteCommitmentTree::Ironwood`, `ScannedBlock::ironwood`, and Ironwood
   tree methods on `WalletCommitmentTrees`.
+- The NU6.3-gated Orchard to Ironwood migration API:
+  `data_api::wallet::create_orchard_to_ironwood_transaction` and
+  `data_api::wallet::MigrationTransaction`.
+- `data_api::wallet::create_pczt_from_proposal_with_tx_version`, for creating
+  a PCZT with an explicitly requested transaction version.
 - `zcash_client_backend::wallet::WalletTransparentOutput`:
   - `recipient_account`
   - `recipient_key_scope`
@@ -50,6 +55,14 @@ workspace.
     Tokio-based batch decryption engine for full blocks and transactions.
 
 ### Changed
+- `zcash_client_backend::fees::orchard::BundleView` no longer exposes a
+  bundle protocol, because fee and change calculation derives Orchard and
+  Ironwood action counts from the bundle inputs and outputs.
+- `zcash_client_backend::data_api::wallet::propose_send_max_transfer` now
+  accepts an explicit transaction version under the `unstable` feature, so
+  callers can request legacy version 5 Orchard send-max proposals after NU6.3.
+  Its `ProposeSendMaxErrT` selection-error parameter is now
+  `GreedyInputSelectorError` instead of `BalanceError`.
 - `zcash_client_backend::data_api`:
   - Changes to the `InputSource` trait:
     - The result types of `InputSource::get_unspent_transparent_output` and
@@ -83,11 +96,18 @@ workspace.
 - `zcash_client_backend::data_api::wallet::input_selection::ShieldingSelector`
   now requires implementors to provide `propose_shielding_coinbase` in
   addition to `propose_shielding`.
+- `zcash_client_backend::wallet::WalletTx::new` now takes a `transparent_outputs`
+  argument.
 - `zcash_client_backend::scanning::ScanError` variants for invalid encodings
   and tree-size failures now report a `NoteCommitmentTree`, so Ironwood scan
   failures are labeled separately from Orchard failures.
-- `zcash_client_backend::wallet::WalletTx::new` now takes a `transparent_outputs`
-  argument.
+- `data_api::wallet::propose_standard_transfer_to_address` and
+  `create_pczt_from_proposal_with_tx_version` keep Orchard change in legacy
+  Orchard form when transaction version 5 is explicitly requested after NU6.3.
+
+### Fixed
+- `data_api::wallet::extract_and_store_transaction_from_pczt` now persists
+  Ironwood sent output metadata added by `create_pczt_from_proposal`.
 
 ### Removed
 - `zcash_client_backend::data_api::WalletUtxo` (use `WalletTransparentOutput`

zcash_client_backend/src/data_api.rs

@@ -433,8 +433,20 @@ impl AccountBalance {
 
     /// Returns the total value of shielded funds that may immediately be spent.
     pub fn spendable_value(&self) -> Zatoshis {
-        (self.sapling_balance.spendable_value + self.orchard_balance.spendable_value)
-            .expect("Account balance cannot overflow MAX_MONEY")
+        let spendable = (self.sapling_balance.spendable_value
+            + self.orchard_balance.spendable_value)
+            .expect("Account balance cannot overflow MAX_MONEY");
+
+        #[cfg(zcash_unstable = "nu6.3")]
+        {
+            (spendable + self.ironwood_balance.spendable_value)
+                .expect("Account balance cannot overflow MAX_MONEY")
+        }
+
+        #[cfg(not(zcash_unstable = "nu6.3"))]
+        {
+            spendable
+        }
     }
 
     /// Returns the total value of change and/or shielding transaction outputs that are awaiting
@@ -2687,6 +2699,23 @@ impl<AccountId> SentTransactionOutput<AccountId> {
         }
     }
 
+    /// Constructs a new [`SentTransactionOutput`] with explicit note commitment tree metadata.
+    pub(crate) fn from_parts_in_tree(
+        note_commitment_tree: Option<NoteCommitmentTree>,
+        output_index: usize,
+        recipient: Recipient<AccountId>,
+        value: Zatoshis,
+        memo: Option<MemoBytes>,
+    ) -> Self {
+        Self {
+            output_index,
+            note_commitment_tree,
+            recipient,
+            value,
+            memo,
+        }
+    }
+
     /// Returns the index within the transaction that contains the recipient output.
     ///
     /// - If `recipient_address` is a Sapling address, this is an index into the Sapling

zcash_client_backend/src/data_api/testing.rs

@@ -29,6 +29,8 @@ use zcash_keys::{
     keys::{UnifiedAddressRequest, UnifiedFullViewingKey, UnifiedSpendingKey},
 };
 use zcash_note_encryption::Domain;
+#[cfg(feature = "unstable")]
+use zcash_primitives::transaction::TxVersion;
 use zcash_primitives::{
     block::BlockHash,
     transaction::{Transaction, TxId, components::sapling::zip212_enforcement, fees::FeeRule},
@@ -1091,6 +1093,43 @@ where
             memo,
             mode,
             confirmations_policy,
+            #[cfg(feature = "unstable")]
+            None,
+        )
+    }
+
+    /// Invokes [`propose_send_max_transfer`] with an explicit transaction version.
+    #[cfg(feature = "unstable")]
+    #[allow(clippy::type_complexity)]
+    #[allow(clippy::too_many_arguments)]
+    pub fn propose_send_max_transfer_with_tx_version<FeeRuleT>(
+        &mut self,
+        spend_from_account: <DbT as InputSource>::AccountId,
+        fee_rule: &FeeRuleT,
+        to: ZcashAddress,
+        memo: Option<MemoBytes>,
+        mode: MaxSpendMode,
+        confirmations_policy: ConfirmationsPolicy,
+        proposed_version: TxVersion,
+    ) -> Result<
+        Proposal<FeeRuleT, <DbT as InputSource>::NoteRef>,
+        super::wallet::ProposeSendMaxErrT<DbT, Infallible, FeeRuleT>,
+    >
+    where
+        FeeRuleT: FeeRule + Clone,
+    {
+        let network = self.network().clone();
+        propose_send_max_transfer::<_, _, _, Infallible>(
+            self.wallet_mut(),
+            &network,
+            spend_from_account,
+            &[ShieldedProtocol::Sapling, ShieldedProtocol::Orchard],
+            fee_rule,
+            to,
+            memo,
+            mode,
+            confirmations_policy,
+            Some(proposed_version),
         )
     }
 
@@ -1139,6 +1178,53 @@ where
         result
     }
 
+    /// Invokes [`propose_standard_transfer_to_address`] with an explicitly requested
+    /// transaction version.
+    #[cfg(feature = "unstable")]
+    #[allow(clippy::type_complexity)]
+    #[allow(clippy::too_many_arguments)]
+    pub fn propose_standard_transfer_with_tx_version<CommitmentTreeErrT>(
+        &mut self,
+        spend_from_account: <DbT as InputSource>::AccountId,
+        fee_rule: StandardFeeRule,
+        confirmations_policy: ConfirmationsPolicy,
+        to: &Address,
+        amount: Zatoshis,
+        memo: Option<MemoBytes>,
+        change_memo: Option<MemoBytes>,
+        fallback_change_pool: ShieldedProtocol,
+        proposed_version: TxVersion,
+    ) -> Result<
+        Proposal<StandardFeeRule, <DbT as InputSource>::NoteRef>,
+        super::wallet::ProposeTransferErrT<
+            DbT,
+            CommitmentTreeErrT,
+            GreedyInputSelector<DbT>,
+            SingleOutputChangeStrategy<DbT>,
+        >,
+    > {
+        let network = self.network().clone();
+        let result = propose_standard_transfer_to_address::<_, _, CommitmentTreeErrT>(
+            self.wallet_mut(),
+            &network,
+            fee_rule,
+            spend_from_account,
+            confirmations_policy,
+            to,
+            amount,
+            memo,
+            change_memo,
+            fallback_change_pool,
+            Some(proposed_version),
+        );
+
+        if let Ok(proposal) = &result {
+            check_proposal_serialization_roundtrip(self.wallet(), proposal);
+        }
+
+        result
+    }
+
     /// Invokes [`propose_shielding`] with the given arguments.
     ///
     /// [`propose_shielding`]: crate::data_api::wallet::propose_shielding
@@ -1276,6 +1362,39 @@ where
         )
     }
 
+    /// Invokes [`create_pczt_from_proposal_with_tx_version`] with the given arguments.
+    ///
+    /// [`create_pczt_from_proposal_with_tx_version`]: super::wallet::create_pczt_from_proposal_with_tx_version
+    #[cfg(all(feature = "pczt", feature = "unstable"))]
+    #[allow(clippy::type_complexity)]
+    pub fn create_pczt_from_proposal_with_tx_version<InputsErrT, FeeRuleT, ChangeErrT>(
+        &mut self,
+        spend_from_account: <DbT as InputSource>::AccountId,
+        ovk_policy: OvkPolicy,
+        proposal: &Proposal<FeeRuleT, <DbT as InputSource>::NoteRef>,
+        proposed_version: TxVersion,
+    ) -> Result<
+        pczt::Pczt,
+        super::wallet::CreateErrT<DbT, InputsErrT, FeeRuleT, ChangeErrT, DbT::NoteRef>,
+    >
+    where
+        <DbT as WalletRead>::AccountId: serde::Serialize,
+        FeeRuleT: FeeRule,
+    {
+        use super::wallet::create_pczt_from_proposal_with_tx_version;
+
+        let network = self.network().clone();
+
+        create_pczt_from_proposal_with_tx_version(
+            self.wallet_mut(),
+            &network,
+            spend_from_account,
+            ovk_policy,
+            proposal,
+            proposed_version,
+        )
+    }
+
     /// Invokes [`extract_and_store_transaction_from_pczt`] with the given arguments.
     ///
     /// [`extract_and_store_transaction_from_pczt`]: super::wallet::extract_and_store_transaction_from_pczt