diff --git a/Cargo.lock b/Cargo.lock
index 04a039bb6a9..98026e02239 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5798,6 +5798,7 @@ dependencies = [
  "ff",
  "fpe",
  "group",
+ "hdwallet",
  "hex",
  "incrementalmerkletree",
  "jubjub",
@@ -5807,7 +5808,9 @@ dependencies = [
  "rand 0.8.5",
  "rand_core 0.6.4",
  "redjubjub",
+ "ripemd",
  "sapling-crypto",
+ "secp256k1",
  "sha2",
  "subtle",
  "tracing",
@@ -5893,6 +5896,7 @@ dependencies = [
 [[package]]
 name = "zcash_script"
 version = "0.1.16"
+source = "git+https://github.com/ZcashFoundation/zcash_script.git?rev=73f28bed340e698ea0eaad608548508ae4dcbc59#73f28bed340e698ea0eaad608548508ae4dcbc59"
 dependencies = [
  "bindgen",
  "cc",
diff --git a/zebra-chain/src/primitives/zcash_primitives.rs b/zebra-chain/src/primitives/zcash_primitives.rs
index 9d9a9caa4f7..5ce3b50ae34 100644
--- a/zebra-chain/src/primitives/zcash_primitives.rs
+++ b/zebra-chain/src/primitives/zcash_primitives.rs
@@ -3,7 +3,7 @@
 
 use std::{io, ops::Deref};
 
-use zcash_primitives::transaction as zp_tx;
+use zcash_primitives::transaction::{self as zp_tx, TxDigests};
 
 use crate::{
     amount::{Amount, NonNegative},
@@ -231,6 +231,41 @@ impl From<Script> for zcash_primitives::legacy::Script {
     }
 }
 
+/// Precomputed data used for sighash or txid computation.
+#[derive(Debug)]
+pub(crate) struct PrecomputedTxData<'a> {
+    tx_data: zp_tx::TransactionData<PrecomputedAuth<'a>>,
+    txid_parts: TxDigests<blake2b_simd::Hash>,
+    all_previous_outputs: &'a [transparent::Output],
+}
+
+impl<'a> PrecomputedTxData<'a> {
+    pub(crate) fn new(
+        tx: &'a Transaction,
+        branch_id: ConsensusBranchId,
+        all_previous_outputs: &'a [transparent::Output],
+    ) -> PrecomputedTxData<'a> {
+        let alt_tx = convert_tx_to_librustzcash(tx, branch_id)
+            .expect("zcash_primitives and Zebra transaction formats must be compatible");
+        let txid_parts = alt_tx.deref().digest(zp_tx::txid::TxIdDigester);
+
+        let f_transparent = MapTransparent {
+            auth: TransparentAuth {
+                all_prev_outputs: all_previous_outputs,
+            },
+        };
+        let tx_data: zp_tx::TransactionData<PrecomputedAuth> = alt_tx
+            .into_data()
+            .map_authorization(f_transparent, IdentityMap, IdentityMap);
+
+        PrecomputedTxData {
+            tx_data,
+            txid_parts,
+            all_previous_outputs,
+        }
+    }
+}
+
 /// Compute a signature hash using librustzcash.
 ///
 /// # Inputs
@@ -243,21 +278,16 @@ impl From<Script> for zcash_primitives::legacy::Script {
 ///     previous transaction, the input itself, and the index of the input in
 ///     the transaction.
 pub(crate) fn sighash(
-    trans: &Transaction,
+    precomputed_tx_data: &PrecomputedTxData,
     hash_type: HashType,
-    branch_id: ConsensusBranchId,
-    all_previous_outputs: &[transparent::Output],
     input_index: Option<usize>,
     script_code: Option<Vec<u8>>,
 ) -> SigHash {
-    let alt_tx = convert_tx_to_librustzcash(trans, branch_id)
-        .expect("zcash_primitives and Zebra transaction formats must be compatible");
-
     let lock_script: zcash_primitives::legacy::Script;
     let unlock_script: zcash_primitives::legacy::Script;
     let signable_input = match input_index {
         Some(input_index) => {
-            let output = &all_previous_outputs[input_index];
+            let output = &precomputed_tx_data.all_previous_outputs[input_index];
             lock_script = output.lock_script.clone().into();
             unlock_script = zcash_primitives::legacy::Script(script_code.unwrap());
             zp_tx::sighash::SignableInput::Transparent {
@@ -274,18 +304,14 @@ pub(crate) fn sighash(
         None => zp_tx::sighash::SignableInput::Shielded,
     };
 
-    let txid_parts = alt_tx.deref().digest(zp_tx::txid::TxIdDigester);
-    let f_transparent = MapTransparent {
-        auth: TransparentAuth {
-            all_prev_outputs: all_previous_outputs,
-        },
-    };
-    let txdata: zp_tx::TransactionData<PrecomputedAuth> =
-        alt_tx
-            .into_data()
-            .map_authorization(f_transparent, IdentityMap, IdentityMap);
-
-    SigHash(*zp_tx::sighash::signature_hash(&txdata, &signable_input, &txid_parts).as_ref())
+    SigHash(
+        *zp_tx::sighash::signature_hash(
+            &precomputed_tx_data.tx_data,
+            &signable_input,
+            &precomputed_tx_data.txid_parts,
+        )
+        .as_ref(),
+    )
 }
 
 /// Compute the authorizing data commitment of this transaction as specified
diff --git a/zebra-chain/src/transaction.rs b/zebra-chain/src/transaction.rs
index 7d03aa6ee6a..815f01b79d4 100644
--- a/zebra-chain/src/transaction.rs
+++ b/zebra-chain/src/transaction.rs
@@ -33,7 +33,7 @@ pub use serialize::{
     SerializedTransaction, MIN_TRANSPARENT_TX_SIZE, MIN_TRANSPARENT_TX_V4_SIZE,
     MIN_TRANSPARENT_TX_V5_SIZE,
 };
-pub use sighash::{HashType, SigHash};
+pub use sighash::{HashType, SigHash, SigHasher};
 pub use unmined::{
     zip317, UnminedTx, UnminedTxId, VerifiedUnminedTx, MEMPOOL_TRANSACTION_COST_THRESHOLD,
 };
@@ -194,14 +194,21 @@ impl Transaction {
         UnminedTxId::from(self)
     }
 
-    /// Calculate the sighash for the current transaction
+    /// Calculate the sighash for the current transaction.
+    ///
+    /// If you need to compute multiple sighashes for the same transactions,
+    /// it's more efficient to use [`Transaction::sighasher()`].
     ///
     /// # Details
     ///
     /// The `input` argument indicates the transparent Input for which we are
-    /// producing a sighash. It is comprised of the index identifying the
-    /// transparent::Input within the transaction and the transparent::Output
-    /// representing the UTXO being spent by that input.
+    /// producing a sighash, or None if it's a shielded input. It is comprised
+    /// of the index identifying the transparent::Input within the transaction
+    /// and the transparent::Output representing the UTXO being spent by that
+    /// input.
+    ///
+    /// The `script_code` argument indicates the script code being validated
+    /// for transparent inputs, or None if it's a shielded input.
     ///
     /// # Panics
     ///
@@ -217,15 +224,20 @@ impl Transaction {
         input: Option<usize>,
         script_code: Option<Vec<u8>>,
     ) -> SigHash {
-        sighash::SigHasher::new(
-            self,
+        sighash::SigHasher::new(self, branch_id, all_previous_outputs).sighash(
             hash_type,
-            branch_id,
-            all_previous_outputs,
             input,
             script_code,
         )
-        .sighash()
+    }
+
+    /// Return a [`SigHasher`] for this transaction.
+    pub fn sighasher<'a>(
+        &'a self,
+        branch_id: ConsensusBranchId,
+        all_previous_outputs: &'a [transparent::Output],
+    ) -> sighash::SigHasher {
+        sighash::SigHasher::new(self, branch_id, all_previous_outputs)
     }
 
     /// Compute the authorizing data commitment of this transaction as specified
diff --git a/zebra-chain/src/transaction/sighash.rs b/zebra-chain/src/transaction/sighash.rs
index 2d9aa0816c4..6c0eb524daa 100644
--- a/zebra-chain/src/transaction/sighash.rs
+++ b/zebra-chain/src/transaction/sighash.rs
@@ -5,7 +5,7 @@ use super::Transaction;
 use crate::parameters::ConsensusBranchId;
 use crate::transparent;
 
-use crate::primitives::zcash_primitives::sighash;
+use crate::primitives::zcash_primitives::{sighash, PrecomputedTxData};
 
 bitflags::bitflags! {
     /// The different SigHash types, as defined in <https://zips.z.cash/zip-0143>
@@ -39,47 +39,55 @@ impl AsRef<[u8]> for SigHash {
     }
 }
 
-pub(super) struct SigHasher<'a> {
-    trans: &'a Transaction,
-    hash_type: HashType,
-    branch_id: ConsensusBranchId,
-    all_previous_outputs: &'a [transparent::Output],
-    input_index: Option<usize>,
-    script_code: Option<Vec<u8>>,
+/// A SigHasher context which stores precomputed data that is reused
+/// between sighash computations for the same transaction.
+pub struct SigHasher<'a> {
+    precomputed_tx_data: PrecomputedTxData<'a>,
 }
 
 impl<'a> SigHasher<'a> {
+    /// Create a new SigHasher for the given transaction.
     pub fn new(
         trans: &'a Transaction,
-        hash_type: HashType,
         branch_id: ConsensusBranchId,
         all_previous_outputs: &'a [transparent::Output],
-        input_index: Option<usize>,
-        script_code: Option<Vec<u8>>,
     ) -> Self {
+        let precomputed_tx_data = PrecomputedTxData::new(trans, branch_id, all_previous_outputs);
         SigHasher {
-            trans,
-            hash_type,
-            branch_id,
-            all_previous_outputs,
-            input_index,
-            script_code,
+            precomputed_tx_data,
         }
     }
 
-    pub(super) fn sighash(self) -> SigHash {
-        self.hash_sighash_librustzcash()
-    }
-
-    /// Compute a signature hash using librustzcash.
-    fn hash_sighash_librustzcash(&self) -> SigHash {
+    /// Calculate the sighash for the current transaction.
+    ///
+    /// # Details
+    ///
+    /// The `input` argument indicates the transparent Input for which we are
+    /// producing a sighash, or None if it's a shielded input. It is comprised
+    /// of the index identifying the transparent::Input within the transaction
+    /// and the transparent::Output representing the UTXO being spent by that
+    /// input.
+    ///
+    /// The `script_code` argument indicates the script code being validated
+    /// for transparent inputs, or None if it's a shielded input.
+    ///
+    /// # Panics
+    ///
+    /// - if passed in any NetworkUpgrade from before NetworkUpgrade::Overwinter
+    /// - if called on a v1 or v2 transaction
+    /// - if the input index points to a transparent::Input::CoinBase
+    /// - if the input index is out of bounds for self.inputs()
+    pub fn sighash(
+        &self,
+        hash_type: HashType,
+        input_index: Option<usize>,
+        script_code: Option<Vec<u8>>,
+    ) -> SigHash {
         sighash(
-            self.trans,
-            self.hash_type,
-            self.branch_id,
-            self.all_previous_outputs,
-            self.input_index,
-            self.script_code.clone(),
+            &self.precomputed_tx_data,
+            hash_type,
+            input_index,
+            script_code,
         )
     }
 }
diff --git a/zebra-chain/src/transaction/tests/vectors.rs b/zebra-chain/src/transaction/tests/vectors.rs
index 03eb7717052..3c23024c73c 100644
--- a/zebra-chain/src/transaction/tests/vectors.rs
+++ b/zebra-chain/src/transaction/tests/vectors.rs
@@ -7,6 +7,7 @@ use lazy_static::lazy_static;
 use crate::{
     block::{Block, Height, MAX_BLOCK_BYTES},
     parameters::Network,
+    primitives::zcash_primitives::PrecomputedTxData,
     serialization::{SerializationError, ZcashDeserialize, ZcashDeserializeInto, ZcashSerialize},
     transaction::{sighash::SigHasher, txid::TxIdBuilder},
     transparent::Script,
@@ -607,14 +608,11 @@ fn test_vec143_1() -> Result<()> {
 
     let hasher = SigHasher::new(
         &transaction,
-        HashType::ALL,
         NetworkUpgrade::Overwinter.branch_id().unwrap(),
         &[],
-        None,
-        None,
     );
 
-    let hash = hasher.sighash();
+    let hash = hasher.sighash(HashType::ALL, None, None);
     let expected = "a1f1a4e5cd9bd522322d661edd2af1bf2a7019cfab94ece18f4ba935b0a19073";
     let result = hex::encode(hash);
     let span = tracing::span!(
@@ -646,14 +644,15 @@ fn test_vec143_2() -> Result<()> {
 
     let hasher = SigHasher::new(
         &transaction,
-        HashType::SINGLE,
         NetworkUpgrade::Overwinter.branch_id().unwrap(),
         &all_previous_outputs,
+    );
+
+    let hash = hasher.sighash(
+        HashType::SINGLE,
         Some(input_ind),
         Some(lock_script.as_raw_bytes().to_vec()),
     );
-
-    let hash = hasher.sighash();
     let expected = "23652e76cb13b85a0e3363bb5fca061fa791c40c533eccee899364e6e60bb4f7";
     let result: &[u8] = hash.as_ref();
     let result = hex::encode(result);
@@ -677,14 +676,11 @@ fn test_vec243_1() -> Result<()> {
 
     let hasher = SigHasher::new(
         &transaction,
-        HashType::ALL,
         NetworkUpgrade::Sapling.branch_id().unwrap(),
         &[],
-        None,
-        None,
     );
 
-    let hash = hasher.sighash();
+    let hash = hasher.sighash(HashType::ALL, None, None);
     let expected = "63d18534de5f2d1c9e169b73f9c783718adbef5c8a7d55b5e7a37affa1dd3ff3";
     let result = hex::encode(hash);
     let span = tracing::span!(
@@ -696,11 +692,14 @@ fn test_vec243_1() -> Result<()> {
     let _guard = span.enter();
     assert_eq!(expected, result);
 
-    let alt_sighash = crate::primitives::zcash_primitives::sighash(
+    let precomputed_tx_data = PrecomputedTxData::new(
         &transaction,
-        HashType::ALL,
         NetworkUpgrade::Sapling.branch_id().unwrap(),
         &[],
+    );
+    let alt_sighash = crate::primitives::zcash_primitives::sighash(
+        &precomputed_tx_data,
+        HashType::ALL,
         None,
         None,
     );
@@ -727,14 +726,15 @@ fn test_vec243_2() -> Result<()> {
 
     let hasher = SigHasher::new(
         &transaction,
-        HashType::NONE,
         NetworkUpgrade::Sapling.branch_id().unwrap(),
         &all_previous_outputs,
+    );
+
+    let hash = hasher.sighash(
+        HashType::NONE,
         Some(input_ind),
         Some(lock_script.as_raw_bytes().to_vec()),
     );
-
-    let hash = hasher.sighash();
     let expected = "bbe6d84f57c56b29b914c694baaccb891297e961de3eb46c68e3c89c47b1a1db";
     let result = hex::encode(hash);
     let span = tracing::span!(
@@ -754,11 +754,14 @@ fn test_vec243_2() -> Result<()> {
     let index = input_ind;
     let all_previous_outputs = mock_pre_v5_output_list(prevout, input_ind);
 
-    let alt_sighash = crate::primitives::zcash_primitives::sighash(
+    let precomputed_tx_data = PrecomputedTxData::new(
         &transaction,
-        HashType::NONE,
         NetworkUpgrade::Sapling.branch_id().unwrap(),
         &all_previous_outputs,
+    );
+    let alt_sighash = crate::primitives::zcash_primitives::sighash(
+        &precomputed_tx_data,
+        HashType::NONE,
         Some(index),
         Some(lock_script.as_raw_bytes().to_vec()),
     );
@@ -786,14 +789,15 @@ fn test_vec243_3() -> Result<()> {
 
     let hasher = SigHasher::new(
         &transaction,
-        HashType::ALL,
         NetworkUpgrade::Sapling.branch_id().unwrap(),
         &all_previous_outputs,
+    );
+
+    let hash = hasher.sighash(
+        HashType::ALL,
         Some(input_ind),
         Some(lock_script.as_raw_bytes().to_vec()),
     );
-
-    let hash = hasher.sighash();
     let expected = "f3148f80dfab5e573d5edfe7a850f5fd39234f80b5429d3a57edcc11e34c585b";
     let result = hex::encode(hash);
     let span = tracing::span!(
@@ -814,11 +818,15 @@ fn test_vec243_3() -> Result<()> {
     };
     let index = input_ind;
 
-    let alt_sighash = crate::primitives::zcash_primitives::sighash(
+    let all_previous_outputs = &[prevout];
+    let precomputed_tx_data = PrecomputedTxData::new(
         &transaction,
-        HashType::ALL,
         NetworkUpgrade::Sapling.branch_id().unwrap(),
-        &[prevout],
+        all_previous_outputs,
+    );
+    let alt_sighash = crate::primitives::zcash_primitives::sighash(
+        &precomputed_tx_data,
+        HashType::ALL,
         Some(index),
         Some(lock_script.as_raw_bytes().to_vec()),
     );
diff --git a/zebra-script/Cargo.toml b/zebra-script/Cargo.toml
index ac69afec92a..81ed94f3789 100644
--- a/zebra-script/Cargo.toml
+++ b/zebra-script/Cargo.toml
@@ -16,7 +16,9 @@ categories = ["api-bindings", "cryptography::cryptocurrencies"]
 
 [dependencies]
 # zcash_script = "0.1.14"
-zcash_script = { path = "/home/conrado/zfnd/zcash_script", version = "0.1.14" }
+# TODO: point to released version after https://github.com/ZcashFoundation/zcash_script/pull/157
+# merges and is included in a release
+zcash_script = { git = "https://github.com/ZcashFoundation/zcash_script.git", rev = "73f28bed340e698ea0eaad608548508ae4dcbc59" }
 
 zebra-chain = { path = "../zebra-chain", version = "1.0.0-beta.37" }
 
diff --git a/zebra-script/src/lib.rs b/zebra-script/src/lib.rs
index a8dec16863e..b1518fc1c3d 100644
--- a/zebra-script/src/lib.rs
+++ b/zebra-script/src/lib.rs
@@ -22,7 +22,7 @@ use zcash_script::{
 
 use zebra_chain::{
     parameters::ConsensusBranchId,
-    transaction::{HashType, Transaction},
+    transaction::{HashType, SigHasher, Transaction},
     transparent,
 };
 
@@ -42,6 +42,9 @@ pub enum Error {
     /// tx is an invalid size for it's protocol
     #[non_exhaustive]
     TxSizeMismatch,
+    /// tx is a coinbase transaction and should not be verified
+    #[non_exhaustive]
+    TxCoinbase,
     /// encountered unknown error kind from zcash_script: {0}
     #[non_exhaustive]
     Unknown(zcash_script_error_t),
@@ -76,12 +79,10 @@ pub struct CachedFfiTransaction {
 
 /// A sighash context used for the zcash_script sighash callback.
 struct SigHashContext<'a> {
-    /// The cached transaction being verified.
-    cached_transaction: &'a CachedFfiTransaction,
-    /// The consensus branch ID of the block containing the transaction.
-    branch_id: ConsensusBranchId,
     /// The index of the input being verified.
     input_index: usize,
+    /// The SigHasher for the transaction being verified.
+    sighasher: SigHasher<'a>,
 }
 
 /// The sighash callback to use with zcash_script.
@@ -101,10 +102,8 @@ extern "C" fn sighash(
         let ctx = ctx as *const SigHashContext;
         let script_code_vec =
             std::slice::from_raw_parts(script_code, script_code_len as usize).to_vec();
-        let sighash = (*ctx).cached_transaction.transaction.sighash(
-            (*ctx).branch_id,
+        let sighash = (*ctx).sighasher.sighash(
             HashType::from_bits_truncate(hash_type as u32),
-            &(*ctx).cached_transaction.all_previous_outputs,
             Some((*ctx).input_index),
             Some(script_code_vec),
         );
@@ -182,14 +181,12 @@ impl CachedFfiTransaction {
                 unlock_script,
                 sequence: _,
             } => unlock_script.as_raw_bytes(),
-            // TODO: how to handle this?
-            transparent::Input::Coinbase { .. } => todo!(),
+            transparent::Input::Coinbase { .. } => Err(Error::TxCoinbase)?,
         };
 
         let ctx = Box::new(SigHashContext {
-            cached_transaction: self,
-            branch_id,
             input_index: n_in,
+            sighasher: SigHasher::new(&self.transaction, branch_id, &self.all_previous_outputs),
         });
         // SAFETY: The `script_*` fields are created from a valid Rust `slice`.
         let ret = unsafe {