Separate out new CovSatisfier from LegacySatisfier

Introspection satisfaction does not require any special satisfier.

Author: sanket1729

src/descriptor/csfs_cov/mod.rs

@@ -48,7 +48,7 @@ mod satisfy;
 mod script_internals;
 pub use self::cov::LegacyCSFSCov;
 pub use self::error::CovError;
-pub use self::satisfy::CovSatisfier;
+pub use self::satisfy::LegacyCovSatisfier;
 pub use self::script_internals::CovOperations;
 
 #[cfg(test)]
@@ -219,7 +219,7 @@ mod tests {
 
         // Try to satisfy the covenant part
         let script_code = desc.cov_script_code();
-        let cov_sat = CovSatisfier::new_segwitv0(
+        let cov_sat = LegacyCovSatisfier::new_segwitv0(
             &spend_tx,
             0,
             confidential::Value::Explicit(200_000),
@@ -412,7 +412,7 @@ mod tests {
         // Try to satisfy the covenant part
         let desc = desc.as_cov().unwrap();
         let script_code = desc.cov_script_code();
-        let cov_sat = CovSatisfier::new_segwitv0(
+        let cov_sat = LegacyCovSatisfier::new_segwitv0(
             &spend_tx,
             0,
             confidential::Value::Explicit(200_000),

src/descriptor/csfs_cov/satisfy.rs

@@ -17,9 +17,7 @@
 use elements::encode::Encodable;
 use elements::hashes::{sha256d, Hash};
 use elements::sighash::SigHashCache;
-use elements::{
-    self, confidential, EcdsaSigHashType, OutPoint, Script, SigHash, Transaction, TxOut,
-};
+use elements::{self, confidential, EcdsaSigHashType, OutPoint, Script, SigHash, Transaction};
 
 use super::CovError;
 use crate::{MiniscriptKey, Satisfier, ToPublicKey};
@@ -30,7 +28,7 @@ use crate::{MiniscriptKey, Satisfier, ToPublicKey};
 /// being satisfied and 'ptx denotes the lifetime
 /// of the previous transaction inputs
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CovSatisfier<'tx, 'ptx> {
+pub struct LegacyCovSatisfier<'tx, 'ptx> {
     // Common fields in Segwit and Taphash
     /// The transaction being spent
     tx: &'tx Transaction,
@@ -45,33 +43,9 @@ pub struct CovSatisfier<'tx, 'ptx> {
     script_code: Option<&'ptx Script>,
     /// The value of the output being spent
     value: Option<confidential::Value>,
-
-    // Taproot
-    /// The utxos used in transaction
-    /// This construction should suffice for Taproot
-    /// related covenant spends too.
-    spent_utxos: Option<&'ptx [TxOut]>,
 }
 
-impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
-    /// Create a new CovSatisfier for taproot spends
-    /// **Panics**
-    /// 1) if number of spent_utxos is not equal to
-    /// number of transaction inputs.
-    /// 2) if idx is out of bounds
-    pub fn new_taproot(tx: &'tx Transaction, spent_utxos: &'ptx [TxOut], idx: u32) -> Self {
-        assert!(spent_utxos.len() == tx.input.len());
-        assert!((idx as usize) < spent_utxos.len());
-        Self {
-            tx,
-            idx,
-            hash_type: EcdsaSigHashType::All, // This is not used in taproot. Update PsbtSigHashType later
-            script_code: None,
-            value: None,
-            spent_utxos: Some(spent_utxos),
-        }
-    }
-
+impl<'tx, 'ptx> LegacyCovSatisfier<'tx, 'ptx> {
     /// Create  a new Covsatisfier for v0 spends
     /// Panics if idx is out of bounds
     pub fn new_segwitv0(
@@ -88,7 +62,6 @@ impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
             hash_type,
             script_code: Some(script_code),
             value: Some(value),
-            spent_utxos: None,
         }
     }
 
@@ -106,15 +79,7 @@ impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
     }
 }
 
-impl<'tx, 'ptx, Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for CovSatisfier<'tx, 'ptx> {
-    fn lookup_spent_utxos(&self) -> Option<&[elements::TxOut]> {
-        self.spent_utxos
-    }
-
-    fn lookup_tx(&self) -> Option<&elements::Transaction> {
-        Some(self.tx)
-    }
-
+impl<'tx, 'ptx, Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for LegacyCovSatisfier<'tx, 'ptx> {
     fn lookup_nversion(&self) -> Option<u32> {
         Some(self.tx.version)
     }

src/descriptor/mod.rs

@@ -60,7 +60,7 @@ pub use self::sh::{Sh, ShInner};
 pub use self::sortedmulti::SortedMultiVec;
 mod checksum;
 mod key;
-pub use self::csfs_cov::{CovError, CovOperations, CovSatisfier, LegacyCSFSCov};
+pub use self::csfs_cov::{CovError, CovOperations, LegacyCSFSCov, LegacyCovSatisfier};
 pub use self::key::{
     ConversionError, DerivedDescriptorKey, DescriptorKeyParseError, DescriptorPublicKey,
     DescriptorSecretKey, DescriptorXKey, InnerXKey, SinglePriv, SinglePub, SinglePubKey, Wildcard,

src/extensions/mod.rs

@@ -6,7 +6,7 @@ use std::{fmt, hash};
 
 use elements::script::Builder;
 use elements::sighash::Prevouts;
-use elements::Transaction;
+use elements::{Transaction, TxOut};
 
 use crate::expression::Tree;
 use crate::interpreter::{self, Stack};
@@ -427,3 +427,43 @@ where
         Ok(ext)
     }
 }
+
+/// A satisfier for Covenant descriptors
+/// that can do transaction introspection
+/// 'tx denotes the lifetime of the transaction
+/// being satisfied and 'ptx denotes the lifetime
+/// of the previous transaction inputs
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CovSatisfier<'tx, 'ptx> {
+    /// The transaction being spent
+    tx: &'tx Transaction,
+    /// Spent utxos
+    spent_utxos: &'ptx [TxOut],
+    /// The input index being spent
+    idx: usize,
+}
+
+impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
+    /// Returns None when spent_utos.len() != tx.input.len()
+    pub fn new(tx: &'tx Transaction, spent_utxos: &'ptx [TxOut], idx: usize) -> Option<Self> {
+        if tx.input.len() != spent_utxos.len() {
+            None
+        } else {
+            Some(Self {
+                tx,
+                spent_utxos,
+                idx,
+            })
+        }
+    }
+}
+
+impl<'tx, 'ptx, Pk: ToPublicKey> Satisfier<Pk> for CovSatisfier<'tx, 'ptx> {
+    fn lookup_tx(&self) -> Option<&elements::Transaction> {
+        Some(self.tx)
+    }
+
+    fn lookup_spent_utxos(&self) -> Option<&[elements::TxOut]> {
+        Some(self.spent_utxos)
+    }
+}

src/psbt/finalizer.rs

@@ -22,14 +22,14 @@
 use bitcoin::{self, PublicKey, XOnlyPublicKey};
 use elements::secp256k1_zkp::{self, Secp256k1};
 use elements::taproot::LeafVersion;
-use elements::{self, confidential, Script, Transaction};
+use elements::{self, confidential, Script, Transaction, TxOut};
 
 use super::{sanity_check, Error, InputError, Psbt, PsbtInputSatisfier};
-use crate::descriptor::{CovSatisfier, LegacyCSFSCov};
-use crate::extensions::CovExtArgs;
+use crate::descriptor::{LegacyCSFSCov, LegacyCovSatisfier};
+use crate::extensions::{CovExtArgs, CovSatisfier};
 use crate::{
-    interpreter, util, BareCtx, Descriptor, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    Tap,
+    interpreter, util, BareCtx, CovenantExt, Descriptor, Legacy, Miniscript, MiniscriptKey,
+    Satisfier, Segwitv0, Tap,
 };
 
 // Get the amount being spent for the psbt input
@@ -51,30 +51,31 @@ fn get_amt(psbt: &Psbt, index: usize) -> Result<confidential::Value, InputError>
 // descriptor from psbt because the information about all the scripts might not
 // be present. Also, currently the spec does not support hidden branches, so
 // inferring a descriptor is not possible
-fn construct_tap_witness(
+fn construct_tap_witness<S>(
     spk: &Script,
-    sat: &PsbtInputSatisfier<'_>,
+    sat: &S,
     allow_mall: bool,
-) -> Result<Vec<Vec<u8>>, InputError> {
+) -> Result<Vec<Vec<u8>>, InputError>
+where
+    S: Satisfier<XOnlyPublicKey>,
+{
     assert!(util::is_v1_p2tr(spk));
 
     // try the key spend path first
-    if let Some(sig) =
-        <PsbtInputSatisfier<'_> as Satisfier<XOnlyPublicKey>>::lookup_tap_key_spend_sig(sat)
-    {
+    if let Some(sig) = sat.lookup_tap_key_spend_sig() {
         return Ok(vec![sig.to_vec()]);
     }
     // Next script spends
     let (mut min_wit, mut min_wit_len) = (None, None);
-    if let Some(block_map) =
-        <PsbtInputSatisfier<'_> as Satisfier<XOnlyPublicKey>>::lookup_tap_control_block_map(sat)
-    {
+    if let Some(block_map) = sat.lookup_tap_control_block_map() {
         for (control_block, (script, ver)) in block_map {
             if *ver != LeafVersion::default() {
                 // We don't know how to satisfy non default version scripts yet
                 continue;
             }
-            let ms = match Miniscript::<XOnlyPublicKey, Tap>::parse_insane(script) {
+            let ms = match Miniscript::<XOnlyPublicKey, Tap, CovenantExt<CovExtArgs>>::parse_insane(
+                script,
+            ) {
                 Ok(ms) => ms,
                 Err(..) => continue, // try another script
             };
@@ -390,6 +391,7 @@ fn input_sanity_checks(psbt: &Psbt, index: usize) -> Result<(), super::Error> {
 fn _finalize_inp(
     psbt: &mut Psbt,
     extracted_tx: &Transaction,
+    spent_utxos: &[TxOut],
     index: usize,
     allow_mall: bool,
 ) -> Result<(), super::Error> {
@@ -399,8 +401,10 @@ fn _finalize_inp(
         let psbt_sat = PsbtInputSatisfier::new(psbt, index);
 
         if util::is_v1_p2tr(spk) {
+            let cov_sat = CovSatisfier::new(&extracted_tx, spent_utxos, index)
+                .ok_or(super::Error::InputError(InputError::MissingUtxo, index))?;
             // Deal with tr case separately, unfortunately we cannot infer the full descriptor for Tr
-            let wit = construct_tap_witness(spk, &psbt_sat, allow_mall)
+            let wit = construct_tap_witness(spk, &(psbt_sat, cov_sat), allow_mall)
                 .map_err(|e| Error::InputError(e, index))?;
             (wit, Script::new())
         } else {
@@ -417,7 +421,7 @@ fn _finalize_inp(
                     .ok_or(super::Error::InputError(InputError::MissingUtxo, index))?;
                 // Codesepartor calculation
                 let script_code = cov.cov_script_code();
-                let cov_sat = CovSatisfier::new_segwitv0(
+                let cov_sat = LegacyCovSatisfier::new_segwitv0(
                     extracted_tx,
                     index as u32,
                     utxo.value,
@@ -477,7 +481,8 @@ pub fn finalize_input<C: secp256k1_zkp::Verification>(
     input_sanity_checks(psbt, index)?;
 
     let extracted_tx = psbt.extract_tx()?;
-    _finalize_inp(psbt, &extracted_tx, index, allow_mall)?;
+    let spent_utxos = prevouts(psbt)?;
+    _finalize_inp(psbt, &extracted_tx, &spent_utxos, index, allow_mall)?;
 
     interpreter_inp_check(psbt, secp, index, genesis_hash)?;
     Ok(())
@@ -504,8 +509,15 @@ pub fn finalize<C: secp256k1_zkp::Verification>(
 
     // Actually construct the witnesses
     let extracted_tx = psbt.extract_tx()?;
+    let spent_utxos = prevouts(psbt)?;
     for index in 0..psbt.inputs().len() {
-        _finalize_inp(psbt, &extracted_tx, index, /*allow_mall*/ false)?;
+        _finalize_inp(
+            psbt,
+            &extracted_tx,
+            &spent_utxos,
+            index,
+            /*allow_mall*/ false,
+        )?;
     }
     // Double check everything with the interpreter
     // This only checks whether the script will be executed

src/psbt/mod.rs

@@ -45,7 +45,7 @@ mod finalizer;
 pub use elements::pset as psbt;
 
 pub use self::finalizer::{finalize, finalize_input, interpreter_check, interpreter_inp_check};
-use crate::descriptor::{CovSatisfier, Tr};
+use crate::descriptor::{LegacyCovSatisfier, Tr};
 use crate::util;
 
 /// Error type for entire Psbt
@@ -300,7 +300,8 @@ pub struct PsbtInputSatisfier<'psbt> {
 /// Psbt Input Satisfier with Covenant support. Users should be
 /// using the high level [`finalizer::finalize`] API.
 /// The [`CovSatisfier`] should be consistent with the extracted transaction.
-pub type PsbtCovInputSatisfier<'psbt> = (PsbtInputSatisfier<'psbt>, CovSatisfier<'psbt, 'psbt>);
+pub type PsbtCovInputSatisfier<'psbt> =
+    (PsbtInputSatisfier<'psbt>, LegacyCovSatisfier<'psbt, 'psbt>);
 
 impl<'psbt> PsbtInputSatisfier<'psbt> {
     /// create a new PsbtInputsatisfier from

tests/test_arith.rs

@@ -12,12 +12,10 @@ use elements::{
 };
 use elementsd::ElementsD;
 use miniscript::miniscript::iter;
-use miniscript::psbt::PsbtInputExt;
+use miniscript::psbt::{PsbtExt, PsbtInputExt};
 use miniscript::{Descriptor, MiniscriptKey, ToPublicKey};
 use rand::RngCore;
 mod setup;
-use miniscript::descriptor::CovSatisfier;
-use miniscript::psbt::PsbtInputSatisfier;
 use setup::test_util::{self, TestData, PARAMS};
 use setup::Call;
 use {actual_rand as rand, elements_miniscript as miniscript};
@@ -164,15 +162,16 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
     println!("Testing descriptor: {}", desc);
     // Finalize the transaction using psbt
     // Let miniscript do it's magic!
-    let psbt_sat = PsbtInputSatisfier::new(&psbt, 0);
-    let mut tx = psbt.extract_tx().unwrap();
-    let utxos = [witness_utxo];
-    let unsigned_tx = &tx.clone();
-    let cov_sat = CovSatisfier::new_taproot(unsigned_tx, &utxos, 0);
-
-    derived_desc
-        .satisfy(&mut tx.input[0], (psbt_sat, cov_sat))
-        .expect("Satisfaction error");
+    if let Err(e) = psbt.finalize_mall_mut(&secp, testdata.pubdata.genesis_hash) {
+        // All miniscripts should satisfy
+        panic!(
+            "Could not satisfy non-malleably: error{} desc:{} ",
+            e[0], desc
+        );
+    }
+    let tx = psbt
+        .extract(&secp, testdata.pubdata.genesis_hash)
+        .expect("Extraction error");
 
     // Send the transactions to bitcoin node for mining.
     // Regtest mode has standardness checks