Proper usk update branch

components/zcash_address/src/lib.rs

@@ -154,7 +154,7 @@ pub struct ZcashAddress {
 
 /// Known kinds of Zcash addresses.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-enum AddressKind {
+pub enum AddressKind {
     Sprout([u8; 64]),
     Sapling([u8; 43]),
     Unified(unified::Address),
@@ -302,6 +302,10 @@ impl ZcashAddress {
             _ => false,
         }
     }
+
+    pub fn kind(&self) -> &AddressKind {
+        &self.kind
+    }
 }
 
 #[cfg(feature = "test-dependencies")]

zcash_client_backend/CHANGELOG.md

@@ -5,7 +5,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this library adheres to Rust's notion of
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [Zingo]
+- replace create_proposed_transaction with `calculate_proposed_transaction`
+  - dont try to write the calculated transaction to wallet, that will be handled later
+  - ignore collecting any transaction metadata
+  - handle usk differently
+- modify change algorithm
+- added display for NoteId
 
 ### Added
 - `zcash_client_backend::data_api`:

zcash_client_backend/Cargo.toml

@@ -72,6 +72,7 @@ tonic = { workspace = true, optional = true, features = ["prost", "codegen"] }
 # - Secret management
 secrecy.workspace = true
 subtle.workspace = true
+secp256k1.workspace = true
 
 # - Shielded protocols
 bls12_381.workspace = true

zcash_client_backend/build.rs

@@ -43,7 +43,7 @@ fn build() -> io::Result<()> {
 
     // Build the gRPC types and client.
     tonic_build::configure()
-        .build_server(false)
+        .build_server(true)
         .client_mod_attribute(
             "cash.z.wallet.sdk.rpc",
             r#"#[cfg(feature = "lightwalletd-tonic")]"#,

zcash_client_backend/src/data_api/chain/error.rs

@@ -27,7 +27,7 @@ impl<WE: fmt::Display, BE: fmt::Display> fmt::Display for Error<WE, BE> {
             Error::Wallet(e) => {
                 write!(
                     f,
-                    "The underlying datasource produced the following error: {}",
+                    "The underlying data source produced the following error: {}",
                     e
                 )
             }

zcash_client_backend/src/data_api/error.rs

@@ -103,7 +103,7 @@ where
             Error::DataSource(e) => {
                 write!(
                     f,
-                    "The underlying datasource produced the following error: {}",
+                    "The underlying data source produced the following error: {}",
                     e
                 )
             }

zcash_client_backend/src/data_api/wallet.rs

@@ -52,7 +52,7 @@ use crate::{
     fees::{self, DustOutputPolicy},
     keys::UnifiedSpendingKey,
     proposal::{self, Proposal, ProposalError},
-    wallet::{Note, OvkPolicy, Recipient},
+    wallet::{Note, OvkPolicy, Recipient, TransparentAddressMetadata},
     zip321::{self, Payment},
     PoolType, ShieldedProtocol,
 };
@@ -597,9 +597,10 @@ where
     ParamsT: consensus::Parameters + Clone,
     FeeRuleT: FeeRule,
 {
+    unimplemented!();
     let mut step_results = Vec::with_capacity(proposal.steps().len());
     for step in proposal.steps() {
-        let step_result = create_proposed_transaction(
+        let step_result = calculate_proposed_transaction(
             wallet_db,
             params,
             spend_prover,
@@ -610,6 +611,7 @@ where
             proposal.min_target_height(),
             &step_results,
             step,
+            None,
         )?;
         step_results.push((step, step_result));
     }
@@ -623,9 +625,10 @@ where
     .expect("proposal.steps is NonEmpty"))
 }
 
+/// Zingo uses calculate_proposed_transaction to create the transaction, and then stores it ASYNCRONOUSLY
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::type_complexity)]
-fn create_proposed_transaction<DbT, ParamsT, InputsErrT, FeeRuleT, N>(
+pub fn calculate_proposed_transaction<DbT, ParamsT, InputsErrT, FeeRuleT, N>(
     wallet_db: &mut DbT,
     params: &ParamsT,
     spend_prover: &impl SpendProver,
@@ -636,9 +639,10 @@ fn create_proposed_transaction<DbT, ParamsT, InputsErrT, FeeRuleT, N>(
     min_target_height: BlockHeight,
     prior_step_results: &[(&proposal::Step<N>, BuildResult)],
     proposal_step: &proposal::Step<N>,
+    override_sapling_change_address: Option<sapling::PaymentAddress>,
 ) -> Result<BuildResult, ErrorT<DbT, InputsErrT, FeeRuleT>>
 where
-    DbT: WalletWrite + WalletCommitmentTrees,
+    DbT: WalletRead + WalletCommitmentTrees,
     ParamsT: consensus::Parameters + Clone,
     FeeRuleT: FeeRule,
 {
@@ -806,10 +810,12 @@ where
                 .clone()
                 .ok_or_else(|| Error::NoSpendingKey(addr.encode(params)))?;
 
-            let secret_key = usk
-                .transparent()
-                .derive_secret_key(address_metadata.scope(), address_metadata.address_index())
-                .unwrap();
+            let secret_key = usk.transparent()
+                        .derive_secret_key(
+                            address_metadata.scope(),
+                            address_metadata.address_index(),
+                        )
+                        .unwrap();
 
             utxos_spent.push(outpoint.clone());
             builder.add_transparent_input(secret_key, outpoint, utxo)?;
@@ -922,10 +928,6 @@ where
         Some(sapling_dfvk.to_ovk(Scope::Internal))
     };
 
-    #[cfg(feature = "orchard")]
-    let mut orchard_output_meta = vec![];
-    let mut sapling_output_meta = vec![];
-    let mut transparent_output_meta = vec![];
     for (payment, output_pool) in proposal_step
         .payment_pools()
         .iter()
@@ -962,11 +964,6 @@ where
                             payment.amount().into(),
                             memo.clone(),
                         )?;
-                        orchard_output_meta.push((
-                            Recipient::External(payment.recipient_address().clone(), *output_pool),
-                            payment.amount(),
-                            Some(memo),
-                        ));
                     }
 
                     PoolType::Shielded(ShieldedProtocol::Sapling) => {
@@ -976,11 +973,6 @@ where
                             payment.amount(),
                             memo.clone(),
                         )?;
-                        sapling_output_meta.push((
-                            Recipient::External(payment.recipient_address().clone(), *output_pool),
-                            payment.amount(),
-                            Some(memo),
-                        ));
                     }
 
                     PoolType::Transparent => {
@@ -1003,23 +995,13 @@ where
                     payment.amount(),
                     memo.clone(),
                 )?;
-                sapling_output_meta.push((
-                    Recipient::External(payment.recipient_address().clone(), PoolType::SAPLING),
-                    payment.amount(),
-                    Some(memo),
-                ));
             }
             Address::Transparent(to) => {
                 if payment.memo().is_some() {
                     return Err(Error::MemoForbidden);
                 } else {
                     builder.add_transparent_output(&to, payment.amount())?;
                 }
-                transparent_output_meta.push((
-                    Recipient::External(payment.recipient_address().clone(), PoolType::TRANSPARENT),
-                    to,
-                    payment.amount(),
-                ));
             }
             Address::Tex(_) => {
                 return Err(Error::ProposalNotSupported);
@@ -1036,19 +1018,10 @@ where
             PoolType::Shielded(ShieldedProtocol::Sapling) => {
                 builder.add_sapling_output(
                     sapling_internal_ovk(),
-                    sapling_dfvk.change_address().1,
+                    override_sapling_change_address.unwrap_or(sapling_dfvk.change_address().1),
                     change_value.value(),
                     memo.clone(),
                 )?;
-                sapling_output_meta.push((
-                    Recipient::InternalAccount {
-                        receiving_account: account,
-                        external_address: None,
-                        note: output_pool,
-                    },
-                    change_value.value(),
-                    Some(memo),
-                ))
             }
             PoolType::Shielded(ShieldedProtocol::Orchard) => {
                 #[cfg(not(feature = "orchard"))]
@@ -1058,19 +1031,10 @@ where
                 {
                     builder.add_orchard_output(
                         orchard_internal_ovk(),
-                        orchard_fvk.address_at(0u32, orchard::keys::Scope::Internal),
+                        orchard_fvk.address_at(0u32, orchard::keys::Scope::External),
                         change_value.value().into(),
                         memo.clone(),
                     )?;
-                    orchard_output_meta.push((
-                        Recipient::InternalAccount {
-                            receiving_account: account,
-                            external_address: None,
-                            note: output_pool,
-                        },
-                        change_value.value(),
-                        Some(memo),
-                    ))
                 }
             }
             PoolType::Transparent => {
@@ -1082,110 +1046,6 @@ where
     // Build the transaction with the specified fee rule
     let build_result = builder.build(OsRng, spend_prover, output_prover, fee_rule)?;
 
-    #[cfg(feature = "orchard")]
-    let orchard_internal_ivk = orchard_fvk.to_ivk(orchard::keys::Scope::Internal);
-    #[cfg(feature = "orchard")]
-    let orchard_outputs =
-        orchard_output_meta
-            .into_iter()
-            .enumerate()
-            .map(|(i, (recipient, value, memo))| {
-                let output_index = build_result
-                    .orchard_meta()
-                    .output_action_index(i)
-                    .expect("An action should exist in the transaction for each Orchard output.");
-
-                let recipient = recipient
-                    .map_internal_account_note(|pool| {
-                        assert!(pool == PoolType::ORCHARD);
-                        build_result
-                            .transaction()
-                            .orchard_bundle()
-                            .and_then(|bundle| {
-                                bundle
-                                    .decrypt_output_with_key(output_index, &orchard_internal_ivk)
-                                    .map(|(note, _, _)| Note::Orchard(note))
-                            })
-                    })
-                    .internal_account_note_transpose_option()
-                    .expect("Wallet-internal outputs must be decryptable with the wallet's IVK");
-
-                SentTransactionOutput::from_parts(output_index, recipient, value, memo)
-            });
-
-    let sapling_internal_ivk =
-        PreparedIncomingViewingKey::new(&sapling_dfvk.to_ivk(Scope::Internal));
-    let sapling_outputs =
-        sapling_output_meta
-            .into_iter()
-            .enumerate()
-            .map(|(i, (recipient, value, memo))| {
-                let output_index = build_result
-                    .sapling_meta()
-                    .output_index(i)
-                    .expect("An output should exist in the transaction for each Sapling payment.");
-
-                let recipient = recipient
-                    .map_internal_account_note(|pool| {
-                        assert!(pool == PoolType::SAPLING);
-                        build_result
-                            .transaction()
-                            .sapling_bundle()
-                            .and_then(|bundle| {
-                                try_sapling_note_decryption(
-                                    &sapling_internal_ivk,
-                                    &bundle.shielded_outputs()[output_index],
-                                    zip212_enforcement(params, min_target_height),
-                                )
-                                .map(|(note, _, _)| Note::Sapling(note))
-                            })
-                    })
-                    .internal_account_note_transpose_option()
-                    .expect("Wallet-internal outputs must be decryptable with the wallet's IVK");
-
-                SentTransactionOutput::from_parts(output_index, recipient, value, memo)
-            });
-
-    let transparent_outputs =
-        transparent_output_meta
-            .into_iter()
-            .map(|(recipient, addr, value)| {
-                let script = addr.script();
-                let output_index = build_result
-                    .transaction()
-                    .transparent_bundle()
-                    .and_then(|b| {
-                        b.vout
-                            .iter()
-                            .enumerate()
-                            .find(|(_, tx_out)| tx_out.script_pubkey == script)
-                    })
-                    .map(|(index, _)| index)
-                    .expect(
-                        "An output should exist in the transaction for each transparent payment.",
-                    );
-
-                SentTransactionOutput::from_parts(output_index, recipient, value, None)
-            });
-
-    let mut outputs = vec![];
-    #[cfg(feature = "orchard")]
-    outputs.extend(orchard_outputs);
-    outputs.extend(sapling_outputs);
-    outputs.extend(transparent_outputs);
-
-    wallet_db
-        .store_sent_tx(&SentTransaction {
-            tx: build_result.transaction(),
-            created: time::OffsetDateTime::now_utc(),
-            account,
-            outputs,
-            fee_amount: proposal_step.balance().fee_required(),
-            #[cfg(feature = "transparent-inputs")]
-            utxos_spent,
-        })
-        .map_err(Error::DataSource)?;
-
     Ok(build_result)
 }
 

zcash_client_backend/src/data_api/wallet/input_selection.rs

@@ -74,7 +74,7 @@ impl<DE: fmt::Display, SE: fmt::Display> fmt::Display for InputSelectorError<DE,
             InputSelectorError::DataSource(e) => {
                 write!(
                     f,
-                    "The underlying datasource produced the following error: {}",
+                    "The underlying data source produced the following error: {}",
                     e
                 )
             }