diff --git a/benches/circuit.rs b/benches/circuit.rs
index 579a34675..6e3708f94 100644
--- a/benches/circuit.rs
+++ b/benches/circuit.rs
@@ -31,10 +31,7 @@ fn criterion_benchmark<FL: OrchardFlavorBench>(c: &mut Criterion) {
     let pk = ProvingKey::build::<FL>();
 
     let create_bundle = |num_recipients| {
-        let mut builder = Builder::new(
-            BundleType::DEFAULT_VANILLA,
-            Anchor::from_bytes([0; 32]).unwrap(),
-        );
+        let mut builder = Builder::new(BundleType::DEFAULT, Anchor::from_bytes([0; 32]).unwrap());
         for _ in 0..num_recipients {
             builder
                 .add_output(
diff --git a/benches/note_decryption.rs b/benches/note_decryption.rs
index 8f2ce8373..f6247afca 100644
--- a/benches/note_decryption.rs
+++ b/benches/note_decryption.rs
@@ -50,10 +50,7 @@ fn bench_note_decryption<FL: OrchardFlavorBench>(c: &mut Criterion) {
         .collect();
 
     let bundle = {
-        let mut builder = Builder::new(
-            BundleType::DEFAULT_VANILLA,
-            Anchor::from_bytes([0; 32]).unwrap(),
-        );
+        let mut builder = Builder::new(BundleType::DEFAULT, Anchor::from_bytes([0; 32]).unwrap());
         // The builder pads to two actions, and shuffles their order. Add two recipients
         // so the first action is always decryptable.
         builder
diff --git a/src/action.rs b/src/action.rs
index e48eae5b8..5125a0b3b 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -13,7 +13,7 @@ use crate::{
 /// This both creates a note (adding a commitment to the global ledger), and consumes
 /// some note created prior to this action (adding a nullifier to the global ledger).
 #[derive(Debug, Clone)]
-pub struct Action<A, P: OrchardPrimitives> {
+pub struct Action<A, Pr: OrchardPrimitives> {
     /// The nullifier of the note being spent.
     nf: Nullifier,
     /// The randomized verification key for the note being spent.
@@ -21,20 +21,20 @@ pub struct Action<A, P: OrchardPrimitives> {
     /// A commitment to the new note being created.
     cmx: ExtractedNoteCommitment,
     /// The transmitted note ciphertext.
-    encrypted_note: TransmittedNoteCiphertext<P>,
+    encrypted_note: TransmittedNoteCiphertext<Pr>,
     /// A commitment to the net value created or consumed by this action.
     cv_net: ValueCommitment,
     /// The authorization for this action.
     authorization: A,
 }
 
-impl<A, P: OrchardPrimitives> Action<A, P> {
+impl<A, Pr: OrchardPrimitives> Action<A, Pr> {
     /// Constructs an `Action` from its constituent parts.
     pub fn from_parts(
         nf: Nullifier,
         rk: redpallas::VerificationKey<SpendAuth>,
         cmx: ExtractedNoteCommitment,
-        encrypted_note: TransmittedNoteCiphertext<P>,
+        encrypted_note: TransmittedNoteCiphertext<Pr>,
         cv_net: ValueCommitment,
         authorization: A,
     ) -> Self {
@@ -64,7 +64,7 @@ impl<A, P: OrchardPrimitives> Action<A, P> {
     }
 
     /// Returns the encrypted note ciphertext.
-    pub fn encrypted_note(&self) -> &TransmittedNoteCiphertext<P> {
+    pub fn encrypted_note(&self) -> &TransmittedNoteCiphertext<Pr> {
         &self.encrypted_note
     }
 
@@ -84,7 +84,7 @@ impl<A, P: OrchardPrimitives> Action<A, P> {
     }
 
     /// Transitions this action from one authorization state to another.
-    pub fn map<U>(self, step: impl FnOnce(A) -> U) -> Action<U, P> {
+    pub fn map<U>(self, step: impl FnOnce(A) -> U) -> Action<U, Pr> {
         Action {
             nf: self.nf,
             rk: self.rk,
@@ -96,7 +96,7 @@ impl<A, P: OrchardPrimitives> Action<A, P> {
     }
 
     /// Transitions this action from one authorization state to another.
-    pub fn try_map<U, E>(self, step: impl FnOnce(A) -> Result<U, E>) -> Result<Action<U, P>, E> {
+    pub fn try_map<U, E>(self, step: impl FnOnce(A) -> Result<U, E>) -> Result<Action<U, Pr>, E> {
         Ok(Action {
             nf: self.nf,
             rk: self.rk,
@@ -108,7 +108,7 @@ impl<A, P: OrchardPrimitives> Action<A, P> {
     }
 }
 
-impl<P: OrchardPrimitives> DynamicUsage for Action<VerSpendAuthSig, P> {
+impl<Pr: OrchardPrimitives> DynamicUsage for Action<VerSpendAuthSig, Pr> {
     #[inline(always)]
     fn dynamic_usage(&self) -> usize {
         0
@@ -150,20 +150,20 @@ pub(crate) mod testing {
     /// `ActionArb` adapts `arb_...` functions for both Vanilla and ZSA Orchard protocol flavors
     /// in property-based testing, addressing proptest crate limitations.
     #[derive(Debug)]
-    pub struct ActionArb<P: OrchardPrimitives> {
-        phantom: core::marker::PhantomData<P>,
+    pub struct ActionArb<Pr: OrchardPrimitives> {
+        phantom: core::marker::PhantomData<Pr>,
     }
 
-    impl<P: OrchardPrimitives> ActionArb<P> {
+    impl<Pr: OrchardPrimitives> ActionArb<Pr> {
         fn encrypt_note<R: RngCore>(
             note: Note,
             memo: Vec<u8>,
             cmx: &ExtractedNoteCommitment,
             cv_net: &ValueCommitment,
             rng: &mut R,
-        ) -> TransmittedNoteCiphertext<P> {
+        ) -> TransmittedNoteCiphertext<Pr> {
             let encryptor =
-                NoteEncryption::<OrchardDomain<P>>::new(None, note, memo.try_into().unwrap());
+                NoteEncryption::<OrchardDomain<Pr>>::new(None, note, memo.try_into().unwrap());
 
             TransmittedNoteCiphertext {
                 epk_bytes: encryptor.epk().to_bytes().0,
@@ -181,7 +181,7 @@ pub(crate) mod testing {
                 asset in arb_asset_base(),
                 rng_seed in prop::array::uniform32(prop::num::u8::ANY),
                 memo in prop::collection::vec(prop::num::u8::ANY, 512),
-            ) -> Action<(), P> {
+            ) -> Action<(), Pr> {
                 let cmx = ExtractedNoteCommitment::from(note.commitment());
                 let cv_net = ValueCommitment::derive(
                     spend_value - output_value,
@@ -213,7 +213,7 @@ pub(crate) mod testing {
                 fake_sighash in prop::array::uniform32(prop::num::u8::ANY),
                 asset in arb_asset_base(),
                 memo in prop::collection::vec(prop::num::u8::ANY, 512),
-            ) -> Action<VerSpendAuthSig, P> {
+            ) -> Action<VerSpendAuthSig, Pr> {
                 let cmx = ExtractedNoteCommitment::from(note.commitment());
                 let cv_net = ValueCommitment::derive(
                     spend_value - output_value,
@@ -231,7 +231,7 @@ pub(crate) mod testing {
                     cmx,
                     encrypted_note,
                     cv_net,
-                    authorization: VerSpendAuthSig::new(P::default_sighash_version(), sk.sign(rng, &fake_sighash)),
+                    authorization: VerSpendAuthSig::new(Pr::default_sighash_version(), sk.sign(rng, &fake_sighash)),
                 }
             }
         }
diff --git a/src/builder.rs b/src/builder.rs
index 850534350..6f2ca22b2 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -61,9 +61,9 @@ pub enum BundleType {
 
 impl BundleType {
     /// The default bundle type has all flags enabled, ZSA disabled, and does not require a bundle
-    /// to be produced.
-    pub const DEFAULT_VANILLA: BundleType = BundleType::Transactional {
-        flags: Flags::ENABLED_WITHOUT_ZSA,
+    /// to be produced if no spends or outputs have been added to the bundle.
+    pub const DEFAULT: BundleType = BundleType::Transactional {
+        flags: Flags::ENABLED,
         bundle_required: false,
     };
 
@@ -123,7 +123,7 @@ impl BundleType {
     pub fn flags(&self) -> Flags {
         match self {
             BundleType::Transactional { flags, .. } => *flags,
-            BundleType::Coinbase => Flags::SPENDS_DISABLED_WITHOUT_ZSA,
+            BundleType::Coinbase => Flags::SPENDS_DISABLED,
         }
     }
 }
@@ -417,18 +417,18 @@ impl OutputInfo {
     /// Defined in [Zcash Protocol Spec § 4.7.3: Sending Notes (Orchard)][orchardsend].
     ///
     /// [orchardsend]: https://zips.z.cash/protocol/nu5.pdf#orchardsend
-    fn build<P: OrchardPrimitives>(
+    fn build<Pr: OrchardPrimitives>(
         &self,
         cv_net: &ValueCommitment,
         nf_old: Nullifier,
         mut rng: impl RngCore,
-    ) -> (Note, ExtractedNoteCommitment, TransmittedNoteCiphertext<P>) {
+    ) -> (Note, ExtractedNoteCommitment, TransmittedNoteCiphertext<Pr>) {
         let rho = Rho::from_nf_old(nf_old);
         let note = Note::new(self.recipient, self.value, self.asset, rho, &mut rng);
         let cm_new = note.commitment();
         let cmx = cm_new.into();
 
-        let encryptor = NoteEncryption::<OrchardDomain<P>>::new(self.ovk.clone(), note, self.memo);
+        let encryptor = NoteEncryption::<OrchardDomain<Pr>>::new(self.ovk.clone(), note, self.memo);
 
         let encrypted_note = TransmittedNoteCiphertext {
             epk_bytes: encryptor.epk().to_bytes().0,
@@ -474,7 +474,18 @@ struct ActionInfo {
 }
 
 impl ActionInfo {
+    /// Creates an `ActionInfo` with a random `rcv`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the asset types of the spent and output notes do not match.
     fn new(spend: SpendInfo, output: OutputInfo, rng: impl RngCore) -> Self {
+        assert_eq!(
+            spend.note.asset(),
+            output.asset,
+            "spend and recipient note types must be equal"
+        );
+
         ActionInfo {
             spend,
             output,
@@ -483,6 +494,7 @@ impl ActionInfo {
     }
 
     /// Returns the value sum for this action.
+    ///
     /// Split notes do not contribute to the value sum.
     fn value_sum(&self) -> ValueSum {
         let spent_value = if self.spend.split_flag {
@@ -499,21 +511,11 @@ impl ActionInfo {
     /// Defined in [Zcash Protocol Spec § 4.7.3: Sending Notes (Orchard)][orchardsend].
     ///
     /// [orchardsend]: https://zips.z.cash/protocol/nu5.pdf#orchardsend
-    ///
-    /// # Panics
-    ///
-    /// Panics if the asset types of the spent and output notes do not match.
     #[cfg(feature = "circuit")]
     fn build<FL: OrchardFlavor>(
         self,
         mut rng: impl RngCore,
     ) -> (Action<SigningMetadata, FL>, Witnesses) {
-        assert_eq!(
-            self.spend.note.asset(),
-            self.output.asset,
-            "spend and recipient note types must be equal"
-        );
-
         let v_net = self.value_sum();
         let cv_net = ValueCommitment::derive(v_net, self.rcv, self.output.asset);
 
@@ -537,11 +539,6 @@ impl ActionInfo {
     }
 
     fn build_for_pczt(self, mut rng: impl RngCore) -> crate::pczt::Action {
-        assert_eq!(
-            self.spend.note.asset(),
-            self.output.asset,
-            "spend and recipient note types must be equal"
-        );
         let v_net = self.value_sum();
         let cv_net = ValueCommitment::derive(v_net, self.rcv, self.spend.note.asset());
 
@@ -619,6 +616,7 @@ pub type UnauthorizedBundleWithMetadata<V, FL> = (UnauthorizedBundle<V, FL>, Bun
 
 /// A builder for constructing an Orchard [`Bundle`] by specifying notes to spend, outputs to
 /// receive, and assets to burn.
+///
 /// This builder provides a structured way to incrementally assemble the components of a bundle.
 #[derive(Debug)]
 pub struct Builder {
@@ -696,7 +694,7 @@ impl Builder {
         Ok(())
     }
 
-    /// Add an instruction to burn a given amount of a specific asset.
+    /// Adds an instruction to burn a given amount of a specific asset.
     pub fn add_burn(&mut self, asset: AssetBase, value: NoteValue) -> Result<(), BuildError> {
         use alloc::collections::btree_map::Entry;
 
@@ -1004,8 +1002,9 @@ fn build_bundle<B, R: RngCore>(
                     .take(num_asset_pre_actions)
                     .collect::<Vec<_>>();
 
-                // Shuffle the spends and outputs, so that the position does not reveal any
-                // information about the content.
+                // Shuffle the spends and outputs, so that learning the position of a
+                // specific spent note or output note doesn't reveal anything on its own
+                // about the meaning of that note in the transaction context.
                 indexed_spends.shuffle(&mut rng);
                 indexed_outputs.shuffle(&mut rng);
 
@@ -1025,8 +1024,8 @@ fn build_bundle<B, R: RngCore>(
             .take(MIN_ACTIONS.saturating_sub(indexed_spends_outputs.len())),
         );
 
-        // Shuffle the spends and outputs, so that the position does not reveal any information
-        // about the content.
+        // We shuffled the spends and outputs within each `AssetBase` above; now we
+        // shuffle the actions to achieve a similar property across `AssetBase`s.
         indexed_spends_outputs.shuffle(&mut rng);
 
         let mut bundle_meta = BundleMetadata::new(num_requested_spends, num_requested_outputs);
@@ -1058,18 +1057,7 @@ fn build_bundle<B, R: RngCore>(
         .try_fold(ValueSum::zero(), |acc, action| acc + action.value_sum())
         .ok_or(OverflowError)?;
 
-    let burn_vec = burn
-        .into_iter()
-        .map(|(asset, value)| {
-            Ok((
-                asset,
-                NoteValue::from_raw(
-                    u64::try_from(i128::from(value))
-                        .map_err(|_| BuildError::ValueSum(OverflowError))?,
-                ),
-            ))
-        })
-        .collect::<Result<Vec<(AssetBase, NoteValue)>, BuildError>>()?;
+    let burn_vec = burn.into_iter().collect();
 
     finisher(
         pre_actions,
@@ -1222,7 +1210,7 @@ impl MaybeSigned {
     }
 }
 
-impl<Proof: fmt::Debug, V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauthorized>, V, P> {
+impl<P: fmt::Debug, V, Pr: OrchardPrimitives> Bundle<InProgress<P, Unauthorized>, V, Pr> {
     /// Loads the sighash into this bundle, preparing it for signing.
     ///
     /// This API ensures that all signatures are created over the same sighash.
@@ -1230,7 +1218,7 @@ impl<Proof: fmt::Debug, V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauth
         self,
         mut rng: R,
         sighash: [u8; 32],
-    ) -> Bundle<InProgress<Proof, PartiallyAuthorized>, V, P> {
+    ) -> Bundle<InProgress<P, PartiallyAuthorized>, V, Pr> {
         self.map_authorization(
             &mut rng,
             |rng, _, SigningMetadata { dummy_ask, parts }| {
@@ -1238,7 +1226,7 @@ impl<Proof: fmt::Debug, V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauth
                 dummy_ask
                     .map(|ask| {
                         VerSpendAuthSig::new(
-                            P::default_sighash_version(),
+                            Pr::default_sighash_version(),
                             ask.randomize(&parts.alpha).sign(rng, &sighash),
                         )
                     })
@@ -1249,7 +1237,7 @@ impl<Proof: fmt::Debug, V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauth
                 proof: auth.proof,
                 sigs: PartiallyAuthorized {
                     binding_signature: VerBindingSig::new(
-                        P::default_sighash_version(),
+                        Pr::default_sighash_version(),
                         auth.sigs.bsk.sign(rng, &sighash),
                     ),
 
@@ -1260,7 +1248,7 @@ impl<Proof: fmt::Debug, V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauth
     }
 }
 
-impl<V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauthorized>, V, P> {
+impl<V, Pr: OrchardPrimitives> Bundle<InProgress<Proof, Unauthorized>, V, Pr> {
     /// Applies signatures to this bundle, in order to authorize it.
     ///
     /// This is a helper method that wraps [`Bundle::prepare`], [`Bundle::sign`], and
@@ -1270,7 +1258,7 @@ impl<V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauthorized>, V, P> {
         mut rng: R,
         sighash: [u8; 32],
         signing_keys: &[SpendAuthorizingKey],
-    ) -> Result<Bundle<Authorized, V, P>, BuildError> {
+    ) -> Result<Bundle<Authorized, V, Pr>, BuildError> {
         signing_keys
             .iter()
             .fold(self.prepare(&mut rng, sighash), |partial, ask| {
@@ -1280,9 +1268,7 @@ impl<V, P: OrchardPrimitives> Bundle<InProgress<Proof, Unauthorized>, V, P> {
     }
 }
 
-impl<Proof: fmt::Debug, V, P: OrchardPrimitives>
-    Bundle<InProgress<Proof, PartiallyAuthorized>, V, P>
-{
+impl<P: fmt::Debug, V, Pr: OrchardPrimitives> Bundle<InProgress<P, PartiallyAuthorized>, V, Pr> {
     /// Signs this bundle with the given [`SpendAuthorizingKey`].
     ///
     /// This will apply versioned signatures for all notes controlled by this spending key.
@@ -1293,7 +1279,7 @@ impl<Proof: fmt::Debug, V, P: OrchardPrimitives>
             |rng, partial, maybe| match maybe {
                 MaybeSigned::SigningMetadata(parts) if parts.ak == expected_ak => {
                     MaybeSigned::Signature(VerSpendAuthSig::new(
-                        P::default_sighash_version(),
+                        Pr::default_sighash_version(),
                         ask.randomize(&parts.alpha).sign(rng, &partial.sigs.sighash),
                     ))
                 }
@@ -1302,6 +1288,7 @@ impl<Proof: fmt::Debug, V, P: OrchardPrimitives>
             |_, partial| partial,
         )
     }
+
     /// Appends externally computed versioned signatures.
     ///
     /// Each versioned signature will be applied to the one input for which it is valid. An error
@@ -1343,11 +1330,11 @@ impl<Proof: fmt::Debug, V, P: OrchardPrimitives>
     }
 }
 
-impl<V, P: OrchardPrimitives> Bundle<InProgress<Proof, PartiallyAuthorized>, V, P> {
+impl<V, Pr: OrchardPrimitives> Bundle<InProgress<Proof, PartiallyAuthorized>, V, Pr> {
     /// Finalizes this bundle, enabling it to be included in a transaction.
     ///
     /// Returns an error if any signatures are missing.
-    pub fn finalize(self) -> Result<Bundle<Authorized, V, P>, BuildError> {
+    pub fn finalize(self) -> Result<Bundle<Authorized, V, Pr>, BuildError> {
         self.try_map_authorization(
             &mut (),
             |_, _, maybe| maybe.finalize(),
@@ -1475,10 +1462,10 @@ pub mod testing {
     }
 
     /// `BuilderArb` adapts `arb_...` functions for both Vanilla and ZSA Orchard protocol variations
-    /// in property-based testing, addressing proptest crate limitations.    
+    /// in property-based testing, addressing proptest crate limitations.
     #[derive(Debug)]
-    pub struct BuilderArb<P: OrchardPrimitives> {
-        phantom: core::marker::PhantomData<P>,
+    pub struct BuilderArb<Pr: OrchardPrimitives> {
+        phantom: core::marker::PhantomData<Pr>,
     }
 
     impl<FL: OrchardFlavor> BuilderArb<FL> {
@@ -1575,7 +1562,7 @@ mod tests {
         let recipient = fvk.address_at(0u32, Scope::External);
 
         let mut builder = Builder::new(
-            BundleType::DEFAULT_VANILLA,
+            BundleType::DEFAULT,
             EMPTY_ROOTS[MERKLE_DEPTH_ORCHARD].into(),
         );
 
diff --git a/src/bundle.rs b/src/bundle.rs
index edc19f3e5..14ff81d88 100644
--- a/src/bundle.rs
+++ b/src/bundle.rs
@@ -1,8 +1,8 @@
 //! Structs related to bundles of Orchard actions.
 
-pub mod burn_validation;
 use alloc::vec::Vec;
 
+pub mod burn_validation;
 pub mod commitments;
 
 #[cfg(feature = "circuit")]
@@ -38,7 +38,7 @@ use crate::{
 use crate::circuit::{Instance, VerifyingKey};
 
 #[cfg(feature = "circuit")]
-impl<A, P: OrchardPrimitives> Action<A, P> {
+impl<A, Pr: OrchardPrimitives> Action<A, Pr> {
     /// Prepares the public instance for this action, for creating and verifying the
     /// bundle proof.
     pub fn to_instance(&self, flags: Flags, anchor: Anchor) -> Instance {
@@ -70,10 +70,10 @@ pub struct Flags {
     /// guaranteed to be dummy notes. If `true`, the created notes may be either real or
     /// dummy notes.
     outputs_enabled: bool,
-    /// Flag denoting whether ZSA transaction is enabled.
+    /// Flag denoting whether ZSA functionality is enabled in the transaction.
     ///
-    /// If `false`,  all notes within [`Action`]s in the transaction's [`Bundle`] are
-    /// guaranteed to be notes with native asset.
+    /// If `false`, all notes within [`Action`]s in the transaction's [`Bundle`] are
+    /// guaranteed to be notes with native asset. If `true`, `Action`s may use any asset.
     zsa_enabled: bool,
 }
 
@@ -97,7 +97,7 @@ impl Flags {
     }
 
     /// The flag set with both spends and outputs enabled and ZSA disabled.
-    pub const ENABLED_WITHOUT_ZSA: Flags = Flags {
+    pub const ENABLED: Flags = Flags {
         spends_enabled: true,
         outputs_enabled: true,
         zsa_enabled: false,
@@ -111,7 +111,7 @@ impl Flags {
     };
 
     /// The flag set with spends and ZSA disabled.
-    pub const SPENDS_DISABLED_WITHOUT_ZSA: Flags = Flags {
+    pub const SPENDS_DISABLED: Flags = Flags {
         spends_enabled: false,
         outputs_enabled: true,
         zsa_enabled: false,
@@ -149,10 +149,10 @@ impl Flags {
         self.outputs_enabled
     }
 
-    /// Flag denoting whether ZSA transaction is enabled.
+    /// Flag denoting whether ZSA functionality is enabled in the transaction.
     ///
-    /// If `false`,  all notes within [`Action`]s in the transaction's [`Bundle`] are
-    /// guaranteed to be notes with native asset.
+    /// If `false`, all notes within [`Action`]s in the transaction's [`Bundle`] are
+    /// guaranteed to be notes with native asset. If `true`, `Action`s may use any asset.
     pub fn zsa_enabled(&self) -> bool {
         self.zsa_enabled
     }
@@ -203,9 +203,9 @@ pub trait Authorization: fmt::Debug {
 
 /// A bundle of actions to be applied to the ledger.
 #[derive(Clone)]
-pub struct Bundle<A: Authorization, V, P: OrchardPrimitives> {
+pub struct Bundle<A: Authorization, V, Pr: OrchardPrimitives> {
     /// The list of actions that make up this bundle.
-    actions: NonEmpty<Action<A::SpendAuth, P>>,
+    actions: NonEmpty<Action<A::SpendAuth, Pr>>,
     /// Orchard-specific transaction-level flags for this bundle.
     flags: Flags,
     /// The net value moved out of the Orchard shielded pool.
@@ -225,11 +225,11 @@ pub struct Bundle<A: Authorization, V, P: OrchardPrimitives> {
     authorization: A,
 }
 
-impl<A: Authorization, V: fmt::Debug, P: OrchardPrimitives> fmt::Debug for Bundle<A, V, P> {
+impl<A: Authorization, V: fmt::Debug, Pr: OrchardPrimitives> fmt::Debug for Bundle<A, V, Pr> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         /// Helper struct for debug-printing actions without exposing `NonEmpty`.
-        struct Actions<'a, A, P: OrchardPrimitives>(&'a NonEmpty<Action<A, P>>);
-        impl<A: fmt::Debug, P: OrchardPrimitives> fmt::Debug for Actions<'_, A, P> {
+        struct Actions<'a, A, Pr: OrchardPrimitives>(&'a NonEmpty<Action<A, Pr>>);
+        impl<A: fmt::Debug, Pr: OrchardPrimitives> fmt::Debug for Actions<'_, A, Pr> {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 f.debug_list().entries(self.0.iter()).finish()
             }
@@ -245,10 +245,10 @@ impl<A: Authorization, V: fmt::Debug, P: OrchardPrimitives> fmt::Debug for Bundl
     }
 }
 
-impl<A: Authorization, V, P: OrchardPrimitives> Bundle<A, V, P> {
+impl<A: Authorization, V, Pr: OrchardPrimitives> Bundle<A, V, Pr> {
     /// Constructs a `Bundle` from its constituent parts.
     pub fn from_parts(
-        actions: NonEmpty<Action<A::SpendAuth, P>>,
+        actions: NonEmpty<Action<A::SpendAuth, Pr>>,
         flags: Flags,
         value_balance: V,
         burn: Vec<(AssetBase, NoteValue)>,
@@ -268,7 +268,7 @@ impl<A: Authorization, V, P: OrchardPrimitives> Bundle<A, V, P> {
     }
 
     /// Returns the list of actions that make up this bundle.
-    pub fn actions(&self) -> &NonEmpty<Action<A::SpendAuth, P>> {
+    pub fn actions(&self) -> &NonEmpty<Action<A::SpendAuth, Pr>> {
         &self.actions
     }
 
@@ -311,7 +311,7 @@ impl<A: Authorization, V, P: OrchardPrimitives> Bundle<A, V, P> {
     pub fn try_map_value_balance<V0, E, F: FnOnce(V) -> Result<V0, E>>(
         self,
         f: F,
-    ) -> Result<Bundle<A, V0, P>, E> {
+    ) -> Result<Bundle<A, V0, Pr>, E> {
         Ok(Bundle {
             actions: self.actions,
             flags: self.flags,
@@ -329,7 +329,7 @@ impl<A: Authorization, V, P: OrchardPrimitives> Bundle<A, V, P> {
         context: &mut R,
         mut spend_auth: impl FnMut(&mut R, &A, A::SpendAuth) -> U::SpendAuth,
         step: impl FnOnce(&mut R, A) -> U,
-    ) -> Bundle<U, V, P> {
+    ) -> Bundle<U, V, Pr> {
         let authorization = self.authorization;
         Bundle {
             actions: self
@@ -350,7 +350,7 @@ impl<A: Authorization, V, P: OrchardPrimitives> Bundle<A, V, P> {
         context: &mut R,
         mut spend_auth: impl FnMut(&mut R, &A, A::SpendAuth) -> Result<U::SpendAuth, E>,
         step: impl FnOnce(&mut R, A) -> Result<U, E>,
-    ) -> Result<Bundle<U, V, P>, E> {
+    ) -> Result<Bundle<U, V, Pr>, E> {
         let authorization = self.authorization;
         let new_actions = self
             .actions
@@ -465,21 +465,25 @@ impl<A: Authorization, V, P: OrchardPrimitives> Bundle<A, V, P> {
     }
 }
 
-pub(crate) fn derive_bvk<A, V: Clone + Into<i64>, P: OrchardPrimitives>(
-    actions: &NonEmpty<Action<A, P>>,
+pub(crate) fn derive_bvk<A, V: Clone + Into<i64>, Pr: OrchardPrimitives>(
+    actions: &NonEmpty<Action<A, Pr>>,
     value_balance: V,
     burn: &[(AssetBase, NoteValue)],
 ) -> redpallas::VerificationKey<Binding> {
-    let cv_nets: Vec<_> = actions.into_iter().map(|a| a.cv_net().clone()).collect();
-    derive_bvk_raw(&cv_nets, ValueSum::from_raw(value_balance.into()), burn)
+    derive_bvk_raw(
+        actions.into_iter().map(|a| a.cv_net()),
+        ValueSum::from_raw(value_balance.into()),
+        burn,
+    )
 }
 
-pub(crate) fn derive_bvk_raw(
-    cv_nets: &[ValueCommitment],
+pub(crate) fn derive_bvk_raw<'a>(
+    cv_nets: impl IntoIterator<Item = &'a ValueCommitment>,
     value_balance: ValueSum,
     burn: &[(AssetBase, NoteValue)],
 ) -> redpallas::VerificationKey<Binding> {
-    (cv_nets.iter().sum::<ValueCommitment>()
+    // https://p.z.cash/TCR:bad-txns-orchard-binding-signature-invalid?partial
+    (cv_nets.into_iter().sum::<ValueCommitment>()
         - ValueCommitment::derive(
             value_balance,
             ValueCommitTrapdoor::zero(),
@@ -494,7 +498,7 @@ pub(crate) fn derive_bvk_raw(
     .into_bvk()
 }
 
-impl<A: Authorization, V: Copy + Into<i64>, P: OrchardPrimitives> Bundle<A, V, P> {
+impl<A: Authorization, V: Copy + Into<i64>, Pr: OrchardPrimitives> Bundle<A, V, Pr> {
     /// Computes a commitment to the effects of this bundle, suitable for inclusion within
     /// a transaction ID.
     pub fn commitment(&self) -> BundleCommitment {
@@ -549,7 +553,7 @@ impl Authorized {
     }
 }
 
-impl<V, P: OrchardPrimitives> Bundle<Authorized, V, P> {
+impl<V, Pr: OrchardPrimitives> Bundle<Authorized, V, Pr> {
     /// Computes a commitment to the authorizing data within for this bundle.
     ///
     /// This together with `Bundle::commitment` bind the entire bundle.
@@ -573,7 +577,7 @@ impl<V, P: OrchardPrimitives> Bundle<Authorized, V, P> {
 }
 
 #[cfg(feature = "std")]
-impl<V: DynamicUsage, P: OrchardPrimitives> DynamicUsage for Bundle<Authorized, V, P> {
+impl<V: DynamicUsage, Pr: OrchardPrimitives> DynamicUsage for Bundle<Authorized, V, Pr> {
     fn dynamic_usage(&self) -> usize {
         self.actions.tail.dynamic_usage()
             + self.value_balance.dynamic_usage()
@@ -651,16 +655,16 @@ pub mod testing {
     /// `BundleArb` adapts `arb_...` functions for both Vanilla and ZSA Orchard protocol variations
     /// in property-based testing, addressing proptest crate limitations.
     #[derive(Debug)]
-    pub struct BundleArb<P: OrchardPrimitives> {
-        phantom: std::marker::PhantomData<P>,
+    pub struct BundleArb<Pr: OrchardPrimitives> {
+        phantom: std::marker::PhantomData<Pr>,
     }
 
-    impl<P: OrchardPrimitives + Default> BundleArb<P> {
+    impl<Pr: OrchardPrimitives + Default> BundleArb<Pr> {
         /// Generate an unauthorized action having spend and output values less than MAX_NOTE_VALUE / n_actions.
         pub fn arb_unauthorized_action_n(
             n_actions: usize,
             flags: Flags,
-        ) -> impl Strategy<Value = (ValueSum, Action<(), P>)> {
+        ) -> impl Strategy<Value = (ValueSum, Action<(), Pr>)> {
             let spend_value_gen = if flags.spends_enabled {
                 Strategy::boxed(arb_note_value_bounded(MAX_NOTE_VALUE / n_actions as u64))
             } else {
@@ -685,7 +689,7 @@ pub mod testing {
         pub fn arb_action_n(
             n_actions: usize,
             flags: Flags,
-        ) -> impl Strategy<Value = (ValueSum, Action<VerSpendAuthSig, P>)> {
+        ) -> impl Strategy<Value = (ValueSum, Action<VerSpendAuthSig, Pr>)> {
             let spend_value_gen = if flags.spends_enabled {
                 Strategy::boxed(arb_note_value_bounded(MAX_NOTE_VALUE / n_actions as u64))
             } else {
@@ -746,7 +750,7 @@ pub mod testing {
                 anchor in Self::arb_base().prop_map(Anchor::from),
                 flags in Just(flags),
                 burn in vec(Self::arb_asset_to_burn(), 1usize..10)
-            ) -> Bundle<Unauthorized, ValueSum, P> {
+            ) -> Bundle<Unauthorized, ValueSum, Pr> {
                 let (balances, actions): (Vec<ValueSum>, Vec<Action<_, _>>) = acts.into_iter().unzip();
 
                 Bundle::from_parts(
@@ -777,7 +781,7 @@ pub mod testing {
                 fake_sighash in prop::array::uniform32(prop::num::u8::ANY),
                 flags in Just(flags),
                 burn in vec(Self::arb_asset_to_burn(), 1usize..10)
-            ) -> Bundle<Authorized, ValueSum, P> {
+            ) -> Bundle<Authorized, ValueSum, Pr> {
                 let (balances, actions): (Vec<ValueSum>, Vec<Action<_, _>, >) = acts.into_iter().unzip();
                 let rng = StdRng::from_seed(rng_seed);
 
@@ -789,7 +793,7 @@ pub mod testing {
                     anchor,
                     Authorized {
                         proof: Proof::new(fake_proof),
-                        binding_signature: VerBindingSig::new(P::default_sighash_version(), sk.sign(rng, &fake_sighash)),
+                        binding_signature: VerBindingSig::new(Pr::default_sighash_version(), sk.sign(rng, &fake_sighash)),
                     },
                 )
             }
diff --git a/src/bundle/batch.rs b/src/bundle/batch.rs
index 481dadd17..6d679787b 100644
--- a/src/bundle/batch.rs
+++ b/src/bundle/batch.rs
@@ -40,9 +40,9 @@ impl BatchValidator {
     }
 
     /// Adds the proof and RedPallas signatures from the given bundle to the validator.
-    pub fn add_bundle<V: Copy + Into<i64>, P: OrchardPrimitives>(
+    pub fn add_bundle<V: Copy + Into<i64>, Pr: OrchardPrimitives>(
         &mut self,
-        bundle: &Bundle<Authorized, V, P>,
+        bundle: &Bundle<Authorized, V, Pr>,
         sighash: [u8; 32],
     ) {
         for action in bundle.actions().iter() {
diff --git a/src/bundle/commitments.rs b/src/bundle/commitments.rs
index 2a11a308b..4e369fbb7 100644
--- a/src/bundle/commitments.rs
+++ b/src/bundle/commitments.rs
@@ -46,10 +46,14 @@ pub(crate) fn hasher(personal: &[u8; 16]) -> State {
 ///
 /// [zip244]: https://zips.z.cash/zip-0244
 /// [zip246]: https://zips.z.cash/zip-0246
-pub(crate) fn hash_bundle_txid_data<A: Authorization, V: Copy + Into<i64>, P: OrchardPrimitives>(
-    bundle: &Bundle<A, V, P>,
+pub(crate) fn hash_bundle_txid_data<
+    A: Authorization,
+    V: Copy + Into<i64>,
+    Pr: OrchardPrimitives,
+>(
+    bundle: &Bundle<A, V, Pr>,
 ) -> Blake2bHash {
-    P::hash_bundle_txid_data(bundle)
+    Pr::hash_bundle_txid_data(bundle)
 }
 
 /// Construct the commitment for the absent bundle as defined in
@@ -73,11 +77,11 @@ pub fn hash_bundle_txid_empty() -> Blake2bHash {
 ///
 /// [zip244]: https://zips.z.cash/zip-0244
 /// [zip246]: https://zips.z.cash/zip-0246
-pub(crate) fn hash_bundle_auth_data<V, P: OrchardPrimitives>(
-    bundle: &Bundle<Authorized, V, P>,
+pub(crate) fn hash_bundle_auth_data<V, Pr: OrchardPrimitives>(
+    bundle: &Bundle<Authorized, V, Pr>,
     sighash_version_map: &BTreeMap<OrchardSighashVersion, Vec<u8>>,
 ) -> Blake2bHash {
-    P::hash_bundle_auth_data(bundle, sighash_version_map)
+    Pr::hash_bundle_auth_data(bundle, sighash_version_map)
 }
 
 /// Construct the `orchard_auth_digest` commitment for an absent bundle as defined in
@@ -236,7 +240,7 @@ mod tests {
     /// to ensure consistency.
     #[test]
     fn test_hash_bundle_txid_data_for_orchard_vanilla() {
-        let bundle = generate_bundle::<OrchardVanilla>(BundleType::DEFAULT_VANILLA);
+        let bundle = generate_bundle::<OrchardVanilla>(BundleType::DEFAULT);
         let sighash = hash_bundle_txid_data(&bundle);
         assert_eq!(
             sighash.to_hex().as_str(),
@@ -272,7 +276,7 @@ mod tests {
     /// reference value to ensure consistency.
     #[test]
     fn test_hash_bundle_auth_data_for_orchard_vanilla() {
-        let bundle = generate_auth_bundle::<OrchardVanilla>(BundleType::DEFAULT_VANILLA);
+        let bundle = generate_auth_bundle::<OrchardVanilla>(BundleType::DEFAULT);
         let orchard_auth_digest = hash_bundle_auth_data(&bundle, &BTreeMap::new());
         assert_eq!(
             orchard_auth_digest.to_hex().as_str(),
diff --git a/src/note.rs b/src/note.rs
index 67808b81f..8f4e144d9 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -401,17 +401,17 @@ pub(crate) fn rho_for_issuance_note(
 
 /// An encrypted note.
 #[derive(Clone)]
-pub struct TransmittedNoteCiphertext<P: OrchardPrimitives> {
+pub struct TransmittedNoteCiphertext<Pr: OrchardPrimitives> {
     /// The serialization of the ephemeral public key
     pub epk_bytes: [u8; 32],
     /// The encrypted note ciphertext
-    pub enc_ciphertext: P::NoteCiphertextBytes,
+    pub enc_ciphertext: Pr::NoteCiphertextBytes,
     /// An encrypted value that allows the holder of the outgoing cipher
     /// key for the note to recover the note plaintext.
     pub out_ciphertext: [u8; 80],
 }
 
-impl<P: OrchardPrimitives> fmt::Debug for TransmittedNoteCiphertext<P> {
+impl<Pr: OrchardPrimitives> fmt::Debug for TransmittedNoteCiphertext<Pr> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("TransmittedNoteCiphertext")
             .field("epk_bytes", &self.epk_bytes)
diff --git a/src/pczt.rs b/src/pczt.rs
index 8a924cf70..2f2b0a5bb 100644
--- a/src/pczt.rs
+++ b/src/pczt.rs
@@ -363,7 +363,7 @@ mod tests {
 
         // Run the Creator and Constructor roles.
         let mut builder = Builder::new(
-            BundleType::DEFAULT_VANILLA,
+            BundleType::DEFAULT,
             EMPTY_ROOTS[MERKLE_DEPTH_ORCHARD].into(),
         );
         builder
@@ -450,7 +450,7 @@ mod tests {
         };
 
         // Run the Creator and Constructor roles.
-        let mut builder = Builder::new(BundleType::DEFAULT_VANILLA, anchor);
+        let mut builder = Builder::new(BundleType::DEFAULT, anchor);
         builder
             .add_spend(fvk.clone(), note, merkle_path.into())
             .unwrap();
diff --git a/src/primitives/compact_action.rs b/src/primitives/compact_action.rs
index c0cdd742d..ffe5f170e 100644
--- a/src/primitives/compact_action.rs
+++ b/src/primitives/compact_action.rs
@@ -1,7 +1,5 @@
 //! Defines actions for Orchard shielded outputs and compact action for light clients.
 
-// Review hint: this file is largely derived from src/note_encryption.rs
-
 use core::fmt;
 
 use zcash_note_encryption::{note_bytes::NoteBytes, EphemeralKeyBytes, ShieldedOutput};
@@ -13,7 +11,7 @@ use crate::{
 
 use super::{orchard_domain::OrchardDomain, orchard_primitives::OrchardPrimitives};
 
-impl<A, P: OrchardPrimitives> ShieldedOutput<OrchardDomain<P>> for Action<A, P> {
+impl<A, Pr: OrchardPrimitives> ShieldedOutput<OrchardDomain<Pr>> for Action<A, Pr> {
     fn ephemeral_key(&self) -> EphemeralKeyBytes {
         EphemeralKeyBytes(self.encrypted_note().epk_bytes)
     }
@@ -26,38 +24,38 @@ impl<A, P: OrchardPrimitives> ShieldedOutput<OrchardDomain<P>> for Action<A, P>
         self.cmx().to_bytes()
     }
 
-    fn enc_ciphertext(&self) -> Option<&P::NoteCiphertextBytes> {
+    fn enc_ciphertext(&self) -> Option<&Pr::NoteCiphertextBytes> {
         Some(&self.encrypted_note().enc_ciphertext)
     }
 
-    fn enc_ciphertext_compact(&self) -> P::CompactNoteCiphertextBytes {
-        P::CompactNoteCiphertextBytes::from_slice(
-            &self.encrypted_note().enc_ciphertext.as_ref()[..P::COMPACT_NOTE_SIZE],
+    fn enc_ciphertext_compact(&self) -> Pr::CompactNoteCiphertextBytes {
+        Pr::CompactNoteCiphertextBytes::from_slice(
+            &self.encrypted_note().enc_ciphertext.as_ref()[..Pr::COMPACT_NOTE_SIZE],
         )
-        .unwrap()
+        .expect("Pr::CompactNoteCiphertextBytes should have size Pr::COMPACT_NOTE_SIZE")
     }
 }
 
 /// A compact Action for light clients.
 #[derive(Clone)]
-pub struct CompactAction<P: OrchardPrimitives> {
+pub struct CompactAction<Pr: OrchardPrimitives> {
     nullifier: Nullifier,
     cmx: ExtractedNoteCommitment,
     ephemeral_key: EphemeralKeyBytes,
-    enc_ciphertext: P::CompactNoteCiphertextBytes,
+    enc_ciphertext: Pr::CompactNoteCiphertextBytes,
 }
 
-impl<P: OrchardPrimitives> fmt::Debug for CompactAction<P> {
+impl<Pr: OrchardPrimitives> fmt::Debug for CompactAction<Pr> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "CompactAction")
     }
 }
 
-impl<A, P: OrchardPrimitives> From<&Action<A, P>> for CompactAction<P>
+impl<A, Pr: OrchardPrimitives> From<&Action<A, Pr>> for CompactAction<Pr>
 where
-    Action<A, P>: ShieldedOutput<OrchardDomain<P>>,
+    Action<A, Pr>: ShieldedOutput<OrchardDomain<Pr>>,
 {
-    fn from(action: &Action<A, P>) -> Self {
+    fn from(action: &Action<A, Pr>) -> Self {
         CompactAction {
             nullifier: *action.nullifier(),
             cmx: *action.cmx(),
@@ -67,7 +65,7 @@ where
     }
 }
 
-impl<P: OrchardPrimitives> ShieldedOutput<OrchardDomain<P>> for CompactAction<P> {
+impl<Pr: OrchardPrimitives> ShieldedOutput<OrchardDomain<Pr>> for CompactAction<Pr> {
     fn ephemeral_key(&self) -> EphemeralKeyBytes {
         EphemeralKeyBytes(self.ephemeral_key.0)
     }
@@ -80,22 +78,22 @@ impl<P: OrchardPrimitives> ShieldedOutput<OrchardDomain<P>> for CompactAction<P>
         self.cmx.to_bytes()
     }
 
-    fn enc_ciphertext(&self) -> Option<&P::NoteCiphertextBytes> {
+    fn enc_ciphertext(&self) -> Option<&Pr::NoteCiphertextBytes> {
         None
     }
 
-    fn enc_ciphertext_compact(&self) -> P::CompactNoteCiphertextBytes {
-        P::CompactNoteCiphertextBytes::from_slice(self.enc_ciphertext.as_ref()).unwrap()
+    fn enc_ciphertext_compact(&self) -> Pr::CompactNoteCiphertextBytes {
+        self.enc_ciphertext
     }
 }
 
-impl<P: OrchardPrimitives> CompactAction<P> {
+impl<Pr: OrchardPrimitives> CompactAction<Pr> {
     /// Create a CompactAction from its constituent parts
     pub fn from_parts(
         nullifier: Nullifier,
         cmx: ExtractedNoteCommitment,
         ephemeral_key: EphemeralKeyBytes,
-        enc_ciphertext: P::CompactNoteCiphertextBytes,
+        enc_ciphertext: Pr::CompactNoteCiphertextBytes,
     ) -> Self {
         Self {
             nullifier,
@@ -141,13 +139,13 @@ pub mod testing {
     /// Creates a fake `CompactAction` paying the given recipient the specified value.
     ///
     /// Returns the `CompactAction` and the new note.
-    pub fn fake_compact_action<R: RngCore, P: OrchardPrimitives>(
+    pub fn fake_compact_action<R: RngCore, Pr: OrchardPrimitives>(
         rng: &mut R,
         nf_old: Nullifier,
         recipient: Address,
         value: NoteValue,
         ovk: Option<OutgoingViewingKey>,
-    ) -> (CompactAction<P>, Note) {
+    ) -> (CompactAction<Pr>, Note) {
         let rho = Rho::from_nf_old(nf_old);
         let rseed = {
             loop {
@@ -160,9 +158,9 @@ pub mod testing {
             }
         };
         let note = Note::from_parts(recipient, value, AssetBase::native(), rho, rseed).unwrap();
-        let encryptor = NoteEncryption::<OrchardDomain<P>>::new(ovk, note, [0u8; MEMO_SIZE]);
+        let encryptor = NoteEncryption::<OrchardDomain<Pr>>::new(ovk, note, [0u8; MEMO_SIZE]);
         let cmx = ExtractedNoteCommitment::from(note.commitment());
-        let ephemeral_key = OrchardDomain::<P>::epk_bytes(encryptor.epk());
+        let ephemeral_key = OrchardDomain::<Pr>::epk_bytes(encryptor.epk());
         let enc_ciphertext = encryptor.encrypt_note_plaintext();
 
         (
@@ -170,8 +168,8 @@ pub mod testing {
                 nullifier: nf_old,
                 cmx,
                 ephemeral_key,
-                enc_ciphertext: P::CompactNoteCiphertextBytes::from_slice(
-                    &enc_ciphertext.as_ref()[..P::COMPACT_NOTE_SIZE],
+                enc_ciphertext: Pr::CompactNoteCiphertextBytes::from_slice(
+                    &enc_ciphertext.as_ref()[..Pr::COMPACT_NOTE_SIZE],
                 )
                 .unwrap(),
             },
diff --git a/src/primitives/orchard_domain.rs b/src/primitives/orchard_domain.rs
index da49de040..e9cfeb38e 100644
--- a/src/primitives/orchard_domain.rs
+++ b/src/primitives/orchard_domain.rs
@@ -1,7 +1,5 @@
 //! Orchard-specific note encryption domain.
 
-// Review hint: this file is largely derived from src/note_encryption.rs
-
 use crate::{
     action::Action, note::Rho, primitives::compact_action::CompactAction,
     primitives::orchard_primitives::OrchardPrimitives,
@@ -9,23 +7,40 @@ use crate::{
 
 /// Orchard-specific note encryption logic.
 #[derive(Debug, Clone)]
-pub struct OrchardDomain<P: OrchardPrimitives> {
+pub struct OrchardDomain<Pr: OrchardPrimitives> {
     /// A parameter needed to generate the nullifier.
     pub rho: Rho,
-    phantom: core::marker::PhantomData<P>,
+    phantom: core::marker::PhantomData<Pr>,
+}
+
+impl<Pr: OrchardPrimitives> memuse::DynamicUsage for OrchardDomain<Pr> {
+    fn dynamic_usage(&self) -> usize {
+        self.rho.dynamic_usage()
+    }
+    fn dynamic_usage_bounds(&self) -> (usize, Option<usize>) {
+        self.rho.dynamic_usage_bounds()
+    }
 }
 
-impl<P: OrchardPrimitives> OrchardDomain<P> {
+impl<Pr: OrchardPrimitives> OrchardDomain<Pr> {
     /// Constructs a domain that can be used to trial-decrypt this action's output note.
-    pub fn for_action<T>(act: &Action<T, P>) -> Self {
+    pub fn for_action<T>(act: &Action<T, Pr>) -> Self {
         Self {
             rho: act.rho(),
             phantom: Default::default(),
         }
     }
 
+    /// Constructs a domain that can be used to trial-decrypt a PCZT action's output note.
+    pub fn for_pczt_action(act: &crate::pczt::Action) -> Self {
+        Self {
+            rho: Rho::from_nf_old(act.spend().nullifier),
+            phantom: Default::default(),
+        }
+    }
+
     /// Constructs a domain that can be used to trial-decrypt this compact action's output note.
-    pub fn for_compact_action(act: &CompactAction<P>) -> Self {
+    pub fn for_compact_action(act: &CompactAction<Pr>) -> Self {
         Self {
             rho: act.rho(),
             phantom: Default::default(),
@@ -34,7 +49,7 @@ impl<P: OrchardPrimitives> OrchardDomain<P> {
 
     /// Constructs a domain from a rho.
     #[cfg(test)]
-    pub fn for_rho(rho: Rho) -> Self {
+    pub(crate) fn for_rho(rho: Rho) -> Self {
         Self {
             rho,
             phantom: Default::default(),
diff --git a/src/primitives/zcash_note_encryption_domain.rs b/src/primitives/zcash_note_encryption_domain.rs
index aecd43a31..a53b8a0c5 100644
--- a/src/primitives/zcash_note_encryption_domain.rs
+++ b/src/primitives/zcash_note_encryption_domain.rs
@@ -36,8 +36,7 @@ const NOTE_VALUE_OFFSET: usize = NOTE_DIVERSIFIER_OFFSET + NOTE_DIVERSIFIER_SIZE
 const NOTE_RSEED_OFFSET: usize = NOTE_VALUE_OFFSET + NOTE_VALUE_SIZE;
 
 /// The size of a Vanilla compact note.
-pub(super) const COMPACT_NOTE_SIZE_VANILLA: usize =
-    NOTE_VERSION_SIZE + NOTE_DIVERSIFIER_SIZE + NOTE_VALUE_SIZE + NOTE_RSEED_SIZE;
+pub(super) const COMPACT_NOTE_SIZE_VANILLA: usize = NOTE_RSEED_OFFSET + NOTE_RSEED_SIZE;
 
 /// The size of the encoding of a ZSA asset.
 const ZSA_ASSET_SIZE: usize = 32;
@@ -93,9 +92,9 @@ pub(super) fn parse_note_version(plaintext: &[u8]) -> Option<u8> {
 /// Parses the note plaintext (excluding the memo) and extracts the note and address if valid.
 /// Domain-specific requirements:
 /// - If the note version is 3, the `plaintext` must contain a valid encoding of a ZSA asset type.
-pub(super) fn parse_note_plaintext_without_memo<P: OrchardPrimitives, F>(
+pub(super) fn parse_note_plaintext_without_memo<Pr: OrchardPrimitives, F>(
     rho: Rho,
-    plaintext: &P::CompactNotePlaintextBytes,
+    plaintext: &Pr::CompactNotePlaintextBytes,
     get_validated_pk_d: F,
 ) -> Option<(Note, Address)>
 where
@@ -125,7 +124,7 @@ where
 
     let pk_d = get_validated_pk_d(&diversifier)?;
     let recipient = Address::from_parts(diversifier, pk_d);
-    let asset = P::extract_asset(plaintext)?;
+    let asset = Pr::extract_asset(plaintext)?;
     let note = Option::from(Note::from_parts(recipient, value, asset, rho, rseed))?;
 
     Some((note, recipient))
@@ -147,7 +146,7 @@ pub(super) fn build_base_note_plaintext_bytes<const NOTE_PLAINTEXT_SIZE: usize>(
     np
 }
 
-impl<P: OrchardPrimitives> Domain for OrchardDomain<P> {
+impl<Pr: OrchardPrimitives> Domain for OrchardDomain<Pr> {
     type EphemeralSecretKey = EphemeralSecretKey;
     type EphemeralPublicKey = EphemeralPublicKey;
     type PreparedEphemeralPublicKey = PreparedEphemeralPublicKey;
@@ -163,10 +162,10 @@ impl<P: OrchardPrimitives> Domain for OrchardDomain<P> {
     type ExtractedCommitmentBytes = [u8; 32];
     type Memo = Memo;
 
-    type NotePlaintextBytes = P::NotePlaintextBytes;
-    type NoteCiphertextBytes = P::NoteCiphertextBytes;
-    type CompactNotePlaintextBytes = P::CompactNotePlaintextBytes;
-    type CompactNoteCiphertextBytes = P::CompactNoteCiphertextBytes;
+    type NotePlaintextBytes = Pr::NotePlaintextBytes;
+    type NoteCiphertextBytes = Pr::NoteCiphertextBytes;
+    type CompactNotePlaintextBytes = Pr::CompactNotePlaintextBytes;
+    type CompactNoteCiphertextBytes = Pr::CompactNoteCiphertextBytes;
 
     fn derive_esk(note: &Self::Note) -> Option<Self::EphemeralSecretKey> {
         Some(note.esk())
@@ -205,8 +204,8 @@ impl<P: OrchardPrimitives> Domain for OrchardDomain<P> {
         secret.kdf_orchard(ephemeral_key)
     }
 
-    fn note_plaintext_bytes(note: &Self::Note, memo: &Self::Memo) -> P::NotePlaintextBytes {
-        P::build_note_plaintext_bytes(note, memo)
+    fn note_plaintext_bytes(note: &Self::Note, memo: &Self::Memo) -> Pr::NotePlaintextBytes {
+        Pr::build_note_plaintext_bytes(note, memo)
     }
 
     fn derive_ock(
@@ -243,9 +242,9 @@ impl<P: OrchardPrimitives> Domain for OrchardDomain<P> {
     fn parse_note_plaintext_without_memo_ivk(
         &self,
         ivk: &Self::IncomingViewingKey,
-        plaintext: &P::CompactNotePlaintextBytes,
+        plaintext: &Pr::CompactNotePlaintextBytes,
     ) -> Option<(Self::Note, Self::Recipient)> {
-        parse_note_plaintext_without_memo::<P, _>(self.rho, plaintext, |diversifier| {
+        parse_note_plaintext_without_memo::<Pr, _>(self.rho, plaintext, |diversifier| {
             Some(DiversifiedTransmissionKey::derive(ivk, diversifier))
         })
     }
@@ -253,16 +252,16 @@ impl<P: OrchardPrimitives> Domain for OrchardDomain<P> {
     fn parse_note_plaintext_without_memo_ovk(
         &self,
         pk_d: &Self::DiversifiedTransmissionKey,
-        plaintext: &P::CompactNotePlaintextBytes,
+        plaintext: &Pr::CompactNotePlaintextBytes,
     ) -> Option<(Self::Note, Self::Recipient)> {
-        parse_note_plaintext_without_memo::<P, _>(self.rho, plaintext, |_| Some(*pk_d))
+        parse_note_plaintext_without_memo::<Pr, _>(self.rho, plaintext, |_| Some(*pk_d))
     }
 
     fn split_plaintext_at_memo(
         &self,
-        plaintext: &P::NotePlaintextBytes,
+        plaintext: &Pr::NotePlaintextBytes,
     ) -> Option<(Self::CompactNotePlaintextBytes, Self::Memo)> {
-        let (compact, memo) = plaintext.as_ref().split_at(P::COMPACT_NOTE_SIZE);
+        let (compact, memo) = plaintext.as_ref().split_at(Pr::COMPACT_NOTE_SIZE);
         Some((
             Self::CompactNotePlaintextBytes::from_slice(compact)?,
             memo.try_into().ok()?,
@@ -279,7 +278,7 @@ impl<P: OrchardPrimitives> Domain for OrchardDomain<P> {
     }
 }
 
-impl<P: OrchardPrimitives> BatchDomain for OrchardDomain<P> {
+impl<Pr: OrchardPrimitives> BatchDomain for OrchardDomain<Pr> {
     fn batch_kdf<'a>(
         items: impl Iterator<Item = (Option<Self::SharedSecret>, &'a EphemeralKeyBytes)>,
     ) -> Vec<Option<Self::SymmetricKey>> {
diff --git a/src/test_vectors/zip32.rs b/src/test_vectors/zip32.rs
index c388858f4..755294dc9 100644
--- a/src/test_vectors/zip32.rs
+++ b/src/test_vectors/zip32.rs
@@ -1,4 +1,4 @@
-// From https://github.com/zcash-hackworks/zcash-test-vectors/blob/master/orchard_zip32.py
+//! Test vectors for Orchard ZIP 32 key derivation.
 
 pub(crate) struct TestVector {
     pub(crate) sk: [u8; 32],
@@ -7,6 +7,7 @@ pub(crate) struct TestVector {
     pub(crate) fp: [u8; 32],
 }
 
+// From https://github.com/zcash-hackworks/zcash-test-vectors/blob/master/orchard_zip32.py
 pub(crate) const TEST_VECTORS: &[TestVector] = &[
     TestVector {
         sk: [
diff --git a/tests/builder.rs b/tests/builder.rs
index 3cf55faa8..c9e2f853e 100644
--- a/tests/builder.rs
+++ b/tests/builder.rs
@@ -16,8 +16,8 @@ use rand::SeedableRng;
 use shardtree::{store::memory::MemoryShardStore, ShardTree};
 use zcash_note_encryption::try_note_decryption;
 
-pub fn verify_bundle<P: OrchardPrimitives>(
-    bundle: &Bundle<Authorized, i64, P>,
+pub fn verify_bundle<Pr: OrchardPrimitives>(
+    bundle: &Bundle<Authorized, i64, Pr>,
     vk: &VerifyingKey,
     verify_proof: bool,
 ) {
@@ -29,7 +29,7 @@ pub fn verify_bundle<P: OrchardPrimitives>(
     for action in bundle.actions() {
         assert_eq!(
             action.authorization().version(),
-            &P::default_sighash_version()
+            &Pr::default_sighash_version()
         );
         assert_eq!(
             action.rk().verify(&sighash, action.authorization().sig()),
@@ -73,8 +73,8 @@ trait BundleOrchardFlavor: OrchardFlavor {
 }
 
 impl BundleOrchardFlavor for OrchardVanilla {
-    const DEFAULT_BUNDLE_TYPE: BundleType = BundleType::DEFAULT_VANILLA;
-    const SPENDS_DISABLED_FLAGS: Flags = Flags::SPENDS_DISABLED_WITHOUT_ZSA;
+    const DEFAULT_BUNDLE_TYPE: BundleType = BundleType::DEFAULT;
+    const SPENDS_DISABLED_FLAGS: Flags = Flags::SPENDS_DISABLED;
 }
 
 impl BundleOrchardFlavor for OrchardZSA {
@@ -154,9 +154,9 @@ fn bundle_chain<FL: BundleOrchardFlavor>() -> ([u8; 32], [u8; 32]) {
 
         let mut builder = Builder::new(
             BundleType::Transactional {
-                // Intentionally testing with SPENDS_DISABLED_WITHOUT_ZSA as SPENDS_DISABLED_WITH_ZSA is already
+                // Intentionally testing with SPENDS_DISABLED as SPENDS_DISABLED_WITH_ZSA is already
                 // tested above (for OrchardZSA case). Both should work.
-                flags: Flags::SPENDS_DISABLED_WITHOUT_ZSA,
+                flags: Flags::SPENDS_DISABLED,
                 bundle_required: false,
             },
             anchor,