diff --git a/zcash_client_sqlite/src/wallet/init.rs b/zcash_client_sqlite/src/wallet/init.rs
index 9fff7e3a3f..2394cc5686 100644
--- a/zcash_client_sqlite/src/wallet/init.rs
+++ b/zcash_client_sqlite/src/wallet/init.rs
@@ -340,7 +340,7 @@ mod tests {
         consensus::{
             self, BlockHeight, BranchId, Network, NetworkConstants, NetworkUpgrade, Parameters,
         },
-        transaction::{TransactionData, TxVersion},
+        transaction::{Transaction, TransactionData, TxVersion},
         zip32::AccountId,
     };
 
@@ -1266,7 +1266,7 @@ mod tests {
                 [],
             )?;
 
-            let tx = TransactionData::from_parts(
+            let tx: Transaction = TransactionData::from_parts(
                 TxVersion::Sapling,
                 BranchId::Canopy,
                 0,
diff --git a/zcash_client_sqlite/src/wallet/init/migrations/add_transaction_views.rs b/zcash_client_sqlite/src/wallet/init/migrations/add_transaction_views.rs
index a84f99a05b..08174aa0f5 100644
--- a/zcash_client_sqlite/src/wallet/init/migrations/add_transaction_views.rs
+++ b/zcash_client_sqlite/src/wallet/init/migrations/add_transaction_views.rs
@@ -295,7 +295,7 @@ mod tests {
                     transparent::{self, Authorized, OutPoint},
                     Amount, TxIn, TxOut,
                 },
-                TransactionData, TxVersion,
+                Transaction, TransactionData, TxVersion,
             },
         },
     };
@@ -413,7 +413,7 @@ mod tests {
         .unwrap();
 
         // create a UTXO to spend
-        let tx = TransactionData::from_parts(
+        let tx: Transaction = TransactionData::from_parts(
             TxVersion::Sapling,
             BranchId::Canopy,
             0,
diff --git a/zcash_extensions/src/transparent/demo.rs b/zcash_extensions/src/transparent/demo.rs
index 40389cbb31..03d53b536a 100644
--- a/zcash_extensions/src/transparent/demo.rs
+++ b/zcash_extensions/src/transparent/demo.rs
@@ -673,7 +673,7 @@ mod tests {
             precondition: tze::Precondition::from(0, &Precondition::open(hash_1)),
         };
 
-        let tx_a = TransactionData::from_parts_zfuture(
+        let tx_a: Transaction = TransactionData::from_parts_zfuture(
             TxVersion::ZFuture,
             BranchId::ZFuture,
             0,
diff --git a/zcash_primitives/src/transaction/components.rs b/zcash_primitives/src/transaction/components.rs
index 3d7b66f7b2..e732464662 100644
--- a/zcash_primitives/src/transaction/components.rs
+++ b/zcash_primitives/src/transaction/components.rs
@@ -264,9 +264,7 @@ impl<A: tze::Authorization> TzePart for Tze<A> {
     type Authorization = A;
 }
 
-pub(super) trait TransparentEnc:
-    TransparentPart<Authorization = transparent::Authorized>
-{
+pub trait TransparentEnc: TransparentPart<Authorization = transparent::Authorized> {
     fn read<R: io::Read>(reader: R) -> io::Result<Option<Self::Bundle>>;
 
     fn write<W: io::Write>(bundle: Option<&Self::Bundle>, writer: W) -> io::Result<()>;
@@ -295,7 +293,7 @@ impl TransparentEnc for NoTransparent {
     }
 }
 
-pub(super) trait SproutEnc: SproutPart {
+pub trait SproutEnc: SproutPart {
     fn read_v4_bundle<R: io::Read>(
         reader: R,
         tx_has_sprout: bool,
@@ -341,9 +339,7 @@ impl SproutEnc for NoSprout {
     }
 }
 
-pub(super) trait SaplingEnc:
-    SaplingPart<Authorization = ::sapling::bundle::Authorized>
-{
+pub trait SaplingEnc: SaplingPart<Authorization = ::sapling::bundle::Authorized> {
     type V4Components;
 
     fn read_v4_components<R: io::Read>(
@@ -463,9 +459,7 @@ impl SaplingEnc for NoSapling {
     }
 }
 
-pub(super) trait OrchardEnc:
-    OrchardPart<Authorization = ::orchard::bundle::Authorized>
-{
+pub trait OrchardEnc: OrchardPart<Authorization = ::orchard::bundle::Authorized> {
     fn read_v5_bundle<R: io::Read>(reader: R) -> io::Result<Option<Self::Bundle>>;
 
     fn write_v5_bundle<W: io::Write>(bundle: Option<&Self::Bundle>, writer: W) -> io::Result<()>;
@@ -488,7 +482,7 @@ impl OrchardEnc for NoOrchard {
 }
 
 #[cfg(zcash_unstable = "zfuture")]
-pub(super) trait TzeEnc: TzePart<Authorization = tze::Authorized> {
+pub trait TzeEnc: TzePart<Authorization = tze::Authorized> {
     fn read_bundle<R: io::Read>(reader: R, tx_has_tze: bool) -> io::Result<Option<Self::Bundle>>;
 
     fn write_bundle<W: io::Write>(
diff --git a/zcash_primitives/src/transaction/mod.rs b/zcash_primitives/src/transaction/mod.rs
index 87e606cf3f..e93ed0d57a 100644
--- a/zcash_primitives/src/transaction/mod.rs
+++ b/zcash_primitives/src/transaction/mod.rs
@@ -299,22 +299,69 @@ impl Authorization for Unauthorized {
 }
 
 /// A Zcash transaction.
-#[derive(Debug)]
-pub struct Transaction {
+pub type Transaction = TransactionWith<AllBundles<Authorized>>;
+
+/// An authorized Zcash transaction with configurable support in the type system for the
+/// various transparent and shielded pools.
+///
+/// If a particular pool is disabled (by using e.g. [`components::NoTransparent`]):
+/// - The pool-specific APIs will be inaccessible.
+/// - The serialization APIs will encode an empty bundle for that pool.
+/// - The parsing APIs will return an error when parsing a transaction with spends or
+///   outputs in that pool.
+pub struct TransactionWith<B>
+where
+    B: Bundles,
+    B::Transparent: TransparentPart<Authorization = transparent::Authorized>,
+    B::Sapling: SaplingPart<Authorization = sapling::bundle::Authorized>,
+    B::Orchard: OrchardPart<Authorization = orchard::bundle::Authorized>,
+{
     txid: TxId,
-    data: TransactionData<AllBundles<Authorized>>,
+    data: TransactionData<B>,
 }
 
-impl Deref for Transaction {
-    type Target = TransactionData<AllBundles<Authorized>>;
+impl<B> fmt::Debug for TransactionWith<B>
+where
+    B: Bundles + fmt::Debug + FutureDebug,
+    B::Transparent: TransparentPart<Authorization = transparent::Authorized> + fmt::Debug,
+    B::Sprout: SproutPart + fmt::Debug,
+    B::Sapling: SaplingPart<Authorization = sapling::bundle::Authorized> + fmt::Debug,
+    B::Orchard: OrchardPart<Authorization = orchard::bundle::Authorized> + fmt::Debug,
+    <B::Transparent as TransparentPart>::Bundle: fmt::Debug,
+    <B::Sprout as SproutPart>::Bundle: fmt::Debug,
+    <B::Sapling as SaplingPart>::Bundle: fmt::Debug,
+    <B::Orchard as OrchardPart>::Bundle: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TransactionWith")
+            .field("txid", &self.txid)
+            .field("data", &self.data)
+            .finish()
+    }
+}
 
-    fn deref(&self) -> &TransactionData<AllBundles<Authorized>> {
+impl<B> Deref for TransactionWith<B>
+where
+    B: Bundles,
+    B::Transparent: TransparentPart<Authorization = transparent::Authorized>,
+    B::Sapling: SaplingPart<Authorization = sapling::bundle::Authorized>,
+    B::Orchard: OrchardPart<Authorization = orchard::bundle::Authorized>,
+{
+    type Target = TransactionData<B>;
+
+    fn deref(&self) -> &TransactionData<B> {
         &self.data
     }
 }
 
-impl PartialEq for Transaction {
-    fn eq(&self, other: &Transaction) -> bool {
+impl<B> PartialEq for TransactionWith<B>
+where
+    B: Bundles,
+    B::Transparent: TransparentPart<Authorization = transparent::Authorized>,
+    B::Sapling: SaplingPart<Authorization = sapling::bundle::Authorized>,
+    B::Orchard: OrchardPart<Authorization = orchard::bundle::Authorized>,
+{
+    fn eq(&self, other: &Self) -> bool {
         self.txid == other.txid
     }
 }
@@ -620,14 +667,47 @@ impl<SA: sapling::bundle::Authorization, B: Bundles<Sapling = Sapling<SA>>> Tran
     }
 }
 
-impl TransactionData<AllBundles<Authorized>> {
-    pub fn freeze(self) -> io::Result<Transaction> {
-        Transaction::from_data(self)
+/// Trait marker for bounds that are not yet required by consensus rules.
+#[cfg(not(zcash_unstable = "zfuture"))]
+pub trait FutureEnc {}
+#[cfg(not(zcash_unstable = "zfuture"))]
+impl<B: Bundles> FutureEnc for B {}
+
+#[cfg(zcash_unstable = "zfuture")]
+pub trait FutureEnc: txid::FutureBundles<FutureTze = Self::FutureEncTze> {
+    type FutureEncTze: TzeEnc;
+}
+#[cfg(zcash_unstable = "zfuture")]
+impl<B> FutureEnc for B
+where
+    B: txid::FutureBundles,
+    B::FutureTze: TzeEnc,
+{
+    type FutureEncTze = B::FutureTze;
+}
+
+impl<B> TransactionData<B>
+where
+    B: Bundles + FutureEnc,
+    B::Transparent: TransparentEnc + txid::TransparentDigester,
+    B::Sprout: SproutEnc,
+    B::Sapling: SaplingEnc + txid::SaplingDigester,
+    B::Orchard: OrchardEnc + txid::OrchardDigester,
+{
+    pub fn freeze(self) -> io::Result<TransactionWith<B>> {
+        TransactionWith::from_data(self)
     }
 }
 
-impl Transaction {
-    fn from_data(data: TransactionData<AllBundles<Authorized>>) -> io::Result<Self> {
+impl<B> TransactionWith<B>
+where
+    B: Bundles + FutureEnc,
+    B::Transparent: TransparentEnc + txid::TransparentDigester,
+    B::Sprout: SproutEnc,
+    B::Sapling: SaplingEnc + txid::SaplingDigester,
+    B::Orchard: OrchardEnc + txid::OrchardDigester,
+{
+    fn from_data(data: TransactionData<B>) -> io::Result<Self> {
         match data.version {
             TxVersion::Sprout(_) | TxVersion::Overwinter | TxVersion::Sapling => {
                 Self::from_data_v4(data)
@@ -638,8 +718,8 @@ impl Transaction {
         }
     }
 
-    fn from_data_v4(data: TransactionData<AllBundles<Authorized>>) -> io::Result<Self> {
-        let mut tx = Transaction {
+    fn from_data_v4(data: TransactionData<B>) -> io::Result<Self> {
+        let mut tx = TransactionWith {
             txid: TxId([0; 32]),
             data,
         };
@@ -649,17 +729,17 @@ impl Transaction {
         Ok(tx)
     }
 
-    fn from_data_v5(data: TransactionData<AllBundles<Authorized>>) -> Self {
+    fn from_data_v5(data: TransactionData<B>) -> Self {
         let txid = to_txid(
             data.version,
             data.consensus_branch_id,
             &data.digest(TxIdDigester),
         );
 
-        Transaction { txid, data }
+        TransactionWith { txid, data }
     }
 
-    pub fn into_data(self) -> TransactionData<AllBundles<Authorized>> {
+    pub fn into_data(self) -> TransactionData<B> {
         self.data
     }
 
@@ -687,7 +767,7 @@ impl Transaction {
         version: TxVersion,
         consensus_branch_id: BranchId,
     ) -> io::Result<Self> {
-        let transparent_bundle = Transparent::read(&mut reader)?;
+        let transparent_bundle = B::Transparent::read(&mut reader)?;
 
         let lock_time = reader.read_u32::<LittleEndian>()?;
         let expiry_height: BlockHeight = if version.has_overwinter() {
@@ -696,19 +776,19 @@ impl Transaction {
             0u32.into()
         };
 
-        let components = Sapling::read_v4_components(&mut reader, version.has_sapling())?;
+        let components = B::Sapling::read_v4_components(&mut reader, version.has_sapling())?;
 
         let sprout_bundle =
-            Sprout::read_v4_bundle(&mut reader, version.has_sprout(), version.has_sapling())?;
+            B::Sprout::read_v4_bundle(&mut reader, version.has_sprout(), version.has_sapling())?;
 
         let sapling_bundle =
-            Sapling::read_v4_binding_sig(&mut reader, version.has_sapling(), components)?;
+            B::Sapling::read_v4_binding_sig(&mut reader, version.has_sapling(), components)?;
 
         let mut txid = [0; 32];
         let hash_bytes = reader.into_hash();
         txid.copy_from_slice(&hash_bytes);
 
-        Ok(Transaction {
+        Ok(TransactionWith {
             txid: TxId(txid),
             data: TransactionData {
                 version,
@@ -735,12 +815,12 @@ impl Transaction {
     fn read_v5<R: Read>(mut reader: R, version: TxVersion) -> io::Result<Self> {
         let (consensus_branch_id, lock_time, expiry_height) =
             Self::read_v5_header_fragment(&mut reader)?;
-        let transparent_bundle = Transparent::read(&mut reader)?;
-        let sapling_bundle = Sapling::read_v5_bundle(&mut reader)?;
-        let orchard_bundle = Orchard::read_v5_bundle(&mut reader)?;
+        let transparent_bundle = B::Transparent::read(&mut reader)?;
+        let sapling_bundle = B::Sapling::read_v5_bundle(&mut reader)?;
+        let orchard_bundle = B::Orchard::read_v5_bundle(&mut reader)?;
 
         #[cfg(zcash_unstable = "zfuture")]
-        let tze_bundle = Tze::read_bundle(&mut reader, version.has_tze())?;
+        let tze_bundle = B::Tze::read_bundle(&mut reader, version.has_tze())?;
 
         let data = TransactionData {
             version,
@@ -799,19 +879,19 @@ impl Transaction {
             writer.write_u32::<LittleEndian>(u32::from(self.expiry_height))?;
         }
 
-        Sapling::write_v4_components(
+        B::Sapling::write_v4_components(
             self.sapling_bundle.as_ref(),
             &mut writer,
             self.version.has_sapling(),
         )?;
 
-        Sprout::write_v4_bundle(
+        B::Sprout::write_v4_bundle(
             self.sprout_bundle.as_ref(),
             &mut writer,
             self.version.has_sprout(),
         )?;
 
-        Sapling::write_v4_binding_sig(
+        B::Sapling::write_v4_binding_sig(
             self.sapling_bundle.as_ref(),
             &mut writer,
             self.version.has_sapling(),
@@ -828,7 +908,7 @@ impl Transaction {
     }
 
     pub fn write_transparent<W: Write>(&self, writer: W) -> io::Result<()> {
-        Transparent::write(self.transparent_bundle.as_ref(), writer)
+        B::Transparent::write(self.transparent_bundle.as_ref(), writer)
     }
 
     pub fn write_v5<W: Write>(&self, mut writer: W) -> io::Result<()> {
@@ -841,7 +921,7 @@ impl Transaction {
         self.write_v5_header(&mut writer)?;
         self.write_transparent(&mut writer)?;
         self.write_v5_sapling(&mut writer)?;
-        Orchard::write_v5_bundle(self.orchard_bundle.as_ref(), &mut writer)?;
+        B::Orchard::write_v5_bundle(self.orchard_bundle.as_ref(), &mut writer)?;
         #[cfg(zcash_unstable = "zfuture")]
         self.write_tze(&mut writer)?;
         Ok(())
@@ -864,14 +944,22 @@ impl Transaction {
     }
 
     pub fn write_v5_sapling<W: Write>(&self, writer: W) -> io::Result<()> {
-        Sapling::write_v5_bundle(self.sapling_bundle.as_ref(), writer)
+        B::Sapling::write_v5_bundle(self.sapling_bundle.as_ref(), writer)
     }
 
     #[cfg(zcash_unstable = "zfuture")]
     pub fn write_tze<W: Write>(&self, writer: W) -> io::Result<()> {
-        Tze::write_bundle(self.tze_bundle.as_ref(), writer, self.version.has_tze())
+        B::Tze::write_bundle(self.tze_bundle.as_ref(), writer, self.version.has_tze())
     }
+}
 
+impl<B> TransactionWith<B>
+where
+    B: Bundles + txid::FutureWitnesses,
+    B::Transparent: txid::TransparentWitnessDigester,
+    B::Sapling: txid::SaplingWitnessDigester,
+    B::Orchard: txid::OrchardWitnessDigester,
+{
     // TODO: should this be moved to `from_data` and stored?
     pub fn auth_commitment(&self) -> Blake2bHash {
         self.data.digest(BlockTxCommitmentDigester)
diff --git a/zcash_primitives/src/transaction/txid.rs b/zcash_primitives/src/transaction/txid.rs
index f80863ab27..34d302446b 100644
--- a/zcash_primitives/src/transaction/txid.rs
+++ b/zcash_primitives/src/transaction/txid.rs
@@ -203,7 +203,7 @@ pub(crate) fn hash_sapling_outputs<A>(shielded_outputs: &[OutputDescription<A>])
     h.finalize()
 }
 
-trait TransparentDigester: TransparentPart {
+pub trait TransparentDigester: TransparentPart {
     fn digest(transparent_bundle: Option<&Self::Bundle>)
         -> Option<TransparentDigests<Blake2bHash>>;
 }
@@ -235,7 +235,7 @@ fn transparent_digests<A: transparent::Authorization>(
 }
 
 #[cfg(zcash_unstable = "zfuture")]
-trait TzeDigester: TzePart {
+pub trait TzeDigester: TzePart {
     fn digest(tze_bundle: Option<&Self::Bundle>) -> Option<TzeDigests<Blake2bHash>>;
 }
 
@@ -290,7 +290,7 @@ pub(crate) fn hash_transparent_txid_data(
     h.finalize()
 }
 
-trait SaplingDigester: SaplingPart {
+pub trait SaplingDigester: SaplingPart {
     fn digest(sapling_bundle: Option<&Self::Bundle>) -> Option<Blake2bHash>;
 }
 
@@ -327,7 +327,7 @@ fn hash_sapling_txid_empty() -> Blake2bHash {
     hasher(ZCASH_SAPLING_HASH_PERSONALIZATION).finalize()
 }
 
-trait OrchardDigester: OrchardPart {
+pub trait OrchardDigester: OrchardPart {
     fn digest(orchard_bundle: Option<&Self::Bundle>) -> Option<Blake2bHash>;
 }
 
@@ -358,12 +358,12 @@ fn hash_tze_txid_data(tze_digests: Option<&TzeDigests<Blake2bHash>>) -> Blake2bH
 
 /// Trait marker for bounds that are not yet required by consensus rules.
 #[cfg(not(zcash_unstable = "zfuture"))]
-trait FutureBundles {}
+pub trait FutureBundles {}
 #[cfg(not(zcash_unstable = "zfuture"))]
 impl<B: Bundles> FutureBundles for B {}
 
 #[cfg(zcash_unstable = "zfuture")]
-trait FutureBundles: Bundles<Tze = Self::FutureTze> {
+pub trait FutureBundles: Bundles<Tze = Self::FutureTze> {
     type FutureTze: TzeDigester;
 }
 #[cfg(zcash_unstable = "zfuture")]
@@ -515,7 +515,9 @@ pub fn to_txid(
     TxId(<[u8; 32]>::try_from(txid_digest.as_bytes()).unwrap())
 }
 
-trait TransparentWitnessDigester: TransparentPart<Authorization = transparent::Authorized> {
+pub trait TransparentWitnessDigester:
+    TransparentPart<Authorization = transparent::Authorized>
+{
     fn witness_digest(transparent_bundle: Option<&Self::Bundle>) -> Blake2bHash;
 }
 
@@ -531,7 +533,7 @@ impl TransparentWitnessDigester for Transparent<transparent::Authorized> {
     }
 }
 
-trait SaplingWitnessDigester: SaplingPart<Authorization = sapling::bundle::Authorized> {
+pub trait SaplingWitnessDigester: SaplingPart<Authorization = sapling::bundle::Authorized> {
     fn witness_digest(sapling_bundle: Option<&Self::Bundle>) -> Blake2bHash;
 }
 
@@ -559,7 +561,7 @@ impl SaplingWitnessDigester for Sapling<sapling::bundle::Authorized> {
     }
 }
 
-trait OrchardWitnessDigester: OrchardPart<Authorization = orchard::Authorized> {
+pub trait OrchardWitnessDigester: OrchardPart<Authorization = orchard::Authorized> {
     fn witness_digest(orchard_bundle: Option<&Self::Bundle>) -> Blake2bHash;
 }
 
@@ -572,7 +574,7 @@ impl OrchardWitnessDigester for Orchard<orchard::Authorized> {
 }
 
 #[cfg(zcash_unstable = "zfuture")]
-trait TzeWitnessDigester: TzePart<Authorization = tze::Authorized> {
+pub trait TzeWitnessDigester: TzePart<Authorization = tze::Authorized> {
     fn witness_digest(tze_bundle: Option<&Self::Bundle>) -> Blake2bHash;
 }
 
@@ -591,12 +593,12 @@ impl TzeWitnessDigester for Tze<tze::Authorized> {
 
 /// Trait marker for bounds that are not yet required by consensus rules.
 #[cfg(not(zcash_unstable = "zfuture"))]
-trait FutureWitnesses {}
+pub trait FutureWitnesses {}
 #[cfg(not(zcash_unstable = "zfuture"))]
 impl<B: Bundles> FutureWitnesses for B {}
 
 #[cfg(zcash_unstable = "zfuture")]
-trait FutureWitnesses: Bundles<Tze = Self::FutureTze> {
+pub trait FutureWitnesses: Bundles<Tze = Self::FutureTze> {
     type FutureTze: TzeWitnessDigester;
 }
 #[cfg(zcash_unstable = "zfuture")]