Add support for transparent-source-only (TEX) addresses

zcash_client_backend/CHANGELOG.md

@@ -28,6 +28,7 @@ funds to those addresses. See [ZIP 320](https://zips.z.cash/zip-0320) for detail
   - `chain::BlockCache` trait, behind the `sync` feature flag.
   - `WalletRead::get_spendable_transparent_outputs`.
 - `zcash_client_backend::fees`:
+  - `EphemeralBalance`
   - `ChangeValue::shielded, is_ephemeral`
   - `ChangeValue::ephemeral_transparent` (when "transparent-inputs" is enabled)
   - `sapling::EmptyBundleView`
@@ -67,10 +68,10 @@ funds to those addresses. See [ZIP 320](https://zips.z.cash/zip-0320) for detail
     return type of `ChangeValue::output_pool` has (unconditionally) changed
     from `ShieldedProtocol` to `zcash_protocol::PoolType`.
   - `ChangeStrategy::compute_balance`: this trait method has an additional
-    `&EphemeralParameters` parameter. If the "transparent-inputs" feature is
+    `Option<&EphemeralBalance>` parameter. If the "transparent-inputs" feature is
     enabled, this can be used to specify whether the change memo should be
     ignored, and the amounts of additional transparent P2PKH inputs and
-    outputs. Passing `&EphemeralParameters::NONE` will retain the previous
+    outputs. Passing `None` will retain the previous
     behaviour (and is necessary when the "transparent-inputs" feature is
     not enabled).
 - `zcash_client_backend::input_selection::GreedyInputSelectorError` has a

zcash_client_backend/src/data_api/wallet/input_selection.rs

@@ -23,7 +23,7 @@
 use crate::{
     address::{Address, UnifiedAddress},
     data_api::{InputSource, SimpleNoteRetention, SpendableNotes},
-    fees::{sapling, ChangeError, ChangeStrategy, DustOutputPolicy, EphemeralParameters},
+    fees::{sapling, ChangeError, ChangeStrategy, DustOutputPolicy},
     proposal::{Proposal, ProposalError, ShieldedInputs},
     wallet::WalletTransparentOutput,
     zip321::TransactionRequest,
@@ -33,7 +33,7 @@
 #[cfg(feature = "transparent-inputs")]
 use {
     crate::{
-        fees::ChangeValue,
+        fees::{ChangeValue, EphemeralBalance},
         proposal::{Step, StepOutput, StepOutputIndex},
         zip321::Payment,
     },
@@ -460,12 +460,12 @@
         }
 
         #[cfg(not(feature = "transparent-inputs"))]
-        let ephemeral_parameters = EphemeralParameters::NONE;
+        let ephemeral_balance = None;
 
         #[cfg(feature = "transparent-inputs")]
-        let (ephemeral_parameters, tr1_balance_opt) = {
+        let (ephemeral_balance, tr1_balance_opt) = {
             if tr1_transparent_outputs.is_empty() {
-                (EphemeralParameters::NONE, None)
+                (None, None)
             } else {
                 // The ephemeral input going into transaction 1 must be able to pay that
                 // transaction's fee, as well as the TEX address payments.
@@ -484,11 +484,11 @@
                         #[cfg(feature = "orchard")]
                         &orchard_fees::EmptyBundleView,
                         &self.dust_output_policy,
-                        &EphemeralParameters::new(true, Some(NonNegativeAmount::ZERO), None),
+                        Some(&EphemeralBalance::Input(NonNegativeAmount::ZERO)),
                     ) {
                         Err(ChangeError::InsufficientFunds { required, .. }) => required,
                         Ok(_) => NonNegativeAmount::ZERO, // shouldn't happen
                         Err(other) => return Err(other.into()),
                     };
 
                 // Now recompute to obtain the `TransactionBalance` and verify that it
@@ -502,12 +502,12 @@
                     #[cfg(feature = "orchard")]
                     &orchard_fees::EmptyBundleView,
                     &self.dust_output_policy,
-                    &EphemeralParameters::new(true, Some(tr1_required_input_value), None),
+                    Some(&EphemeralBalance::Input(tr1_required_input_value)),
                 )?;
                 assert_eq!(tr1_balance.total(), tr1_balance.fee_required());
 
                 (
-                    EphemeralParameters::new(false, None, Some(tr1_required_input_value)),
+                    Some(EphemeralBalance::Output(tr1_required_input_value)),
                     Some(tr1_balance),
                 )
             }
@@ -582,7 +582,7 @@
                     &orchard_outputs[..],
                 ),
                 &self.dust_output_policy,
-                &ephemeral_parameters,
+                ephemeral_balance.as_ref(),
             );
 
             match balance {
@@ -598,7 +598,7 @@
                         }))
                         .map(|notes| ShieldedInputs::from_parts(anchor_height, notes));
 
                     #[cfg(feature = "transparent-inputs")]
                     if let Some(tr1_balance) = tr1_balance_opt {
                         // Construct two new `TransactionRequest`s:
                         // * `tr0` excludes the TEX outputs, and in their place includes
@@ -609,8 +609,8 @@
                         assert_eq!(
                             *balance.proposed_change().last().expect("nonempty"),
                             ChangeValue::ephemeral_transparent(
-                                ephemeral_parameters
-                                    .ephemeral_output_amount()
+                                ephemeral_balance
+                                    .and_then(|b| b.ephemeral_output_amount())
                                     .expect("ephemeral output is present")
                             )
                         );
@@ -773,7 +773,7 @@
             #[cfg(feature = "orchard")]
             &orchard_fees::EmptyBundleView,
             &self.dust_output_policy,
-            &EphemeralParameters::NONE,
+            None,
         );
 
         let balance = match trial_balance {
@@ -786,13 +786,12 @@
                     params,
                     target_height,
                     &transparent_inputs,
                     &[] as &[TxOut],
                     &sapling::EmptyBundleView,
                     #[cfg(feature = "orchard")]
                     &orchard_fees::EmptyBundleView,
                     &self.dust_output_policy,
-                    #[cfg(feature = "transparent-inputs")]
-                    &EphemeralParameters::NONE,
+                    None,
                 )?
             }
             Err(other) => {

zcash_client_backend/src/fees.rs

@@ -330,61 +330,36 @@
     }
 }
 
-/// `EphemeralParameters` can be used to specify variations on how balance
-/// and fees are computed that are relevant to transactions using ephemeral
-/// transparent outputs. These are only relevant when the "transparent-inputs"
-/// feature is enabled, but to reduce feature-dependent boilerplate, the type
-/// and the `EphemeralParameters::NONE` constant are present unconditionally.
+/// `EphemeralBalance` describes the ephemeral input or output value for
+/// a transaction. It is use in the computation of fees are relevant to transactions using
+/// ephemeral transparent outputs.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct EphemeralParameters {
-    ignore_change_memo: bool,
-    ephemeral_input_amount: Option<NonNegativeAmount>,
-    ephemeral_output_amount: Option<NonNegativeAmount>,
+pub enum EphemeralBalance {
+    Input(NonNegativeAmount),
+    Output(NonNegativeAmount),
 }
 
-impl EphemeralParameters {
-    /// An `EphemeralParameters` indicating no use of ephemeral inputs
-    /// or outputs. It has:
-    ///
-    /// * `ignore_change_memo: false`,
-    /// * `ephemeral_input_amount: None`,
-    /// * `ephemeral_output_amount: None`.
-    pub const NONE: Self = Self {
-        ignore_change_memo: false,
-        ephemeral_input_amount: None,
-        ephemeral_output_amount: None,
-    };
-
-    /// Returns an `EphemeralParameters` with the following parameters:
-    ///
-    /// * `ignore_change_memo`: `true` if the change memo should be
-    ///   ignored for the purpose of deciding whether there will be a
-    ///   change output.
-    /// * `ephemeral_input_amount`: specifies that there will be an
-    ///   additional P2PKH input of the given amount.
-    /// * `ephemeral_output_amount`: specifies that there will be an
-    ///   additional P2PKH output of the given amount.
-    #[cfg(feature = "transparent-inputs")]
-    pub const fn new(
-        ignore_change_memo: bool,
-        ephemeral_input_amount: Option<NonNegativeAmount>,
-        ephemeral_output_amount: Option<NonNegativeAmount>,
-    ) -> Self {
-        Self {
-            ignore_change_memo,
-            ephemeral_input_amount,
-            ephemeral_output_amount,
-        }
+impl EphemeralBalance {
+    pub fn is_input(&self) -> bool {
+        matches!(self, EphemeralBalance::Input(_))
     }
 
-    pub fn ignore_change_memo(&self) -> bool {
-        self.ignore_change_memo
+    pub fn is_output(&self) -> bool {
+        matches!(self, EphemeralBalance::Output(_))
     }
+
     pub fn ephemeral_input_amount(&self) -> Option<NonNegativeAmount> {
-        self.ephemeral_input_amount
+        match self {
+            EphemeralBalance::Input(v) => Some(*v),
+            EphemeralBalance::Output(_) => None,
+        }
     }
+
     pub fn ephemeral_output_amount(&self) -> Option<NonNegativeAmount> {
-        self.ephemeral_output_amount
+        match self {
+            EphemeralBalance::Input(_) => None,
+            EphemeralBalance::Output(v) => Some(*v),
+        }
     }
 }
 
@@ -433,7 +408,7 @@
         sapling: &impl sapling::BundleView<NoteRefT>,
         #[cfg(feature = "orchard")] orchard: &impl orchard::BundleView<NoteRefT>,
         dust_output_policy: &DustOutputPolicy,
-        ephemeral_parameters: &EphemeralParameters,
+        ephemeral_balance: Option<&EphemeralBalance>,
     ) -> Result<TransactionBalance, ChangeError<Self::Error, NoteRefT>>;
 }
 

zcash_client_backend/src/fees/common.rs

@@ -12,7 +12,7 @@
 
 use super::{
     sapling as sapling_fees, ChangeError, ChangeValue, DustAction, DustOutputPolicy,
-    EphemeralParameters, TransactionBalance,
+    EphemeralBalance, TransactionBalance,
 };
 
 #[cfg(feature = "orchard")]
@@ -49,8 +49,7 @@
     transparent_outputs: &[impl transparent::OutputView],
     sapling: &impl sapling_fees::BundleView<NoteRefT>,
     #[cfg(feature = "orchard")] orchard: &impl orchard_fees::BundleView<NoteRefT>,
-    ephemeral_input_amount: Option<NonNegativeAmount>,
-    ephemeral_output_amount: Option<NonNegativeAmount>,
+    ephemeral_balance: Option<&EphemeralBalance>,
 ) -> Result<NetFlows, ChangeError<E, NoteRefT>>
 where
     E: From<F::Error> + From<BalanceError>,
@@ -60,13 +59,13 @@
     let t_in = transparent_inputs
         .iter()
         .map(|t_in| t_in.coin().value)
-        .chain(ephemeral_input_amount)
+        .chain(ephemeral_balance.and_then(|b| b.ephemeral_input_amount()))
         .sum::<Option<_>>()
         .ok_or_else(overflow)?;
     let t_out = transparent_outputs
         .iter()
         .map(|t_out| t_out.value())
-        .chain(ephemeral_output_amount)
+        .chain(ephemeral_balance.and_then(|b| b.ephemeral_output_amount()))
         .sum::<Option<_>>()
         .ok_or_else(overflow)?;
     let sapling_in = sapling
@@ -162,12 +161,15 @@
     fallback_change_pool: ShieldedProtocol,
     marginal_fee: NonNegativeAmount,
     grace_actions: usize,
-    ephemeral_parameters: &EphemeralParameters,
+    ephemeral_balance: Option<&EphemeralBalance>,
 ) -> Result<TransactionBalance, ChangeError<E, NoteRefT>>
 where
     E: From<F::Error> + From<BalanceError>,
 {
-    let change_memo = change_memo.filter(|_| !ephemeral_parameters.ignore_change_memo());
+    // The change memo, if any, must be attached to the change in the intermediate step that
+    // produces the ephemeral output, and so it should be discarded in the ultimate step; this is
+    // distinguished by identifying that this transaction has ephemeral inputs.
+    let change_memo = change_memo.filter(|_| ephemeral_balance.map_or(true, |b| !b.is_input()));
 
     let overflow = || ChangeError::StrategyError(E::from(BalanceError::Overflow));
     let underflow = || ChangeError::StrategyError(E::from(BalanceError::Underflow));
@@ -178,8 +180,7 @@
         sapling,
         #[cfg(feature = "orchard")]
         orchard,
-        ephemeral_parameters.ephemeral_input_amount(),
-        ephemeral_parameters.ephemeral_output_amount(),
+        ephemeral_balance,
     )?;
 
     #[allow(unused_variables)]
@@ -213,7 +214,7 @@
             marginal_fee,
             grace_actions,
             &possible_change[..],
-            ephemeral_parameters,
+            ephemeral_balance,
         )?;
     }
 
@@ -287,16 +288,16 @@
         .iter()
         .map(|i| i.serialized_size())
         .chain(
-            ephemeral_parameters
-                .ephemeral_input_amount()
+            ephemeral_balance
+                .and_then(|b| b.ephemeral_input_amount())
                 .map(|_| transparent::InputSize::STANDARD_P2PKH),
         );
     let transparent_output_sizes = transparent_outputs
         .iter()
         .map(|i| i.serialized_size())
         .chain(
-            ephemeral_parameters
-                .ephemeral_output_amount()
+            ephemeral_balance
+                .and_then(|b| b.ephemeral_output_amount())
                 .map(|_| P2PKH_STANDARD_OUTPUT_SIZE),
         );
 
@@ -388,7 +389,7 @@
                             });
                         }
                     }
                     DustAction::AllowDustChange => simple_case(),
                     DustAction::AddDustToFee => {
                         // Zero-valued change is also always allowed for this policy, but when
                         // no change memo is given, we might omit the change output instead.
@@ -404,13 +405,13 @@
                         if fee_with_dust > reasonable_fee {
                             // Defend against losing money by using AddDustToFee with a too-high
                             // dust threshold.
                             simple_case()
                         } else if change_memo.is_some() {
                             (
                                 vec![ChangeValue::shielded(
                                     change_pool,
                                     NonNegativeAmount::ZERO,
                                     change_memo.cloned(),
                                 )],
                                 fee_with_dust,
                             )
@@ -426,8 +427,8 @@
     };
     #[cfg(feature = "transparent-inputs")]
     change.extend(
-        ephemeral_parameters
-            .ephemeral_output_amount()
+        ephemeral_balance
+            .and_then(|b| b.ephemeral_output_amount())
             .map(ChangeValue::ephemeral_transparent),
     );
 
@@ -456,7 +457,7 @@
     marginal_fee: NonNegativeAmount,
     grace_actions: usize,
     possible_change: &[(usize, usize, usize)],
-    ephemeral_parameters: &EphemeralParameters,
+    ephemeral_balance: Option<&EphemeralBalance>,
 ) -> Result<(), ChangeError<E, NoteRefT>> {
     let mut t_dust: Vec<_> = transparent_inputs
         .iter()
@@ -464,7 +465,7 @@
             // For now, we're just assuming P2PKH inputs, so we don't check the
             // size of the input script.
             if i.coin().value <= marginal_fee {
                 Some(i.outpoint().clone())
             } else {
                 None
             }
@@ -504,10 +505,8 @@
     }
 
     let (t_inputs_len, t_outputs_len) = (
-        transparent_inputs.len()
-            + usize::from(ephemeral_parameters.ephemeral_input_amount().is_some()),
-        transparent_outputs.len()
-            + usize::from(ephemeral_parameters.ephemeral_output_amount().is_some()),
+        transparent_inputs.len() + usize::from(ephemeral_balance.map_or(false, |b| b.is_input())),
+        transparent_outputs.len() + usize::from(ephemeral_balance.map_or(false, |b| b.is_output())),
     );
     let (s_inputs_len, s_outputs_len) = (sapling.inputs().len(), sapling.outputs().len());
     #[cfg(feature = "orchard")]
@@ -598,14 +597,14 @@
 
         let (t_extra, s_extra, o_extra) = if baseline >= grace_actions {
             (0, 0, 0)
         } else if t_dust.len() > t_allowed && hypothetical_actions(1, 0, 0)? <= baseline {
             (1, 0, 0)
         } else if s_dust.len() > s_allowed && hypothetical_actions(0, 1, 0)? <= baseline {
             (0, 1, 0)
         } else if o_dust.len() > o_allowed && hypothetical_actions(0, 0, 1)? <= baseline {
             (0, 0, 1)
         } else {
             (0, 0, 0)
         };
         Ok((
             t_allowed + t_extra,

zcash_client_backend/src/fees/fixed.rs

@@ -13,7 +13,7 @@ use crate::ShieldedProtocol;
 
 use super::{
     common::single_change_output_balance, sapling as sapling_fees, ChangeError, ChangeStrategy,
-    DustOutputPolicy, EphemeralParameters, TransactionBalance,
+    DustOutputPolicy, EphemeralBalance, TransactionBalance,
 };
 
 #[cfg(feature = "orchard")]
@@ -63,7 +63,7 @@ impl ChangeStrategy for SingleOutputChangeStrategy {
         sapling: &impl sapling_fees::BundleView<NoteRefT>,
         #[cfg(feature = "orchard")] orchard: &impl orchard_fees::BundleView<NoteRefT>,
         dust_output_policy: &DustOutputPolicy,
-        ephemeral_parameters: &EphemeralParameters,
+        ephemeral_balance: Option<&EphemeralBalance>,
     ) -> Result<TransactionBalance, ChangeError<Self::Error, NoteRefT>> {
         single_change_output_balance(
             params,
@@ -80,7 +80,7 @@ impl ChangeStrategy for SingleOutputChangeStrategy {
             self.fallback_change_pool,
             NonNegativeAmount::ZERO,
             0,
-            ephemeral_parameters,
+            ephemeral_balance,
         )
     }
 }
@@ -100,7 +100,7 @@ mod tests {
         data_api::wallet::input_selection::SaplingPayment,
         fees::{
             tests::{TestSaplingInput, TestTransparentInput},
-            ChangeError, ChangeStrategy, ChangeValue, DustOutputPolicy, EphemeralParameters,
+            ChangeError, ChangeStrategy, ChangeValue, DustOutputPolicy,
         },
         ShieldedProtocol,
     };
@@ -136,7 +136,7 @@ mod tests {
             #[cfg(feature = "orchard")]
             &orchard_fees::EmptyBundleView,
             &DustOutputPolicy::default(),
-            &EphemeralParameters::NONE,
+            None,
         );
 
         assert_matches!(
@@ -182,7 +182,7 @@ mod tests {
             #[cfg(feature = "orchard")]
             &orchard_fees::EmptyBundleView,
             &DustOutputPolicy::default(),
-            &EphemeralParameters::NONE,
+            None,
         );
 
         assert_matches!(