Clean up interpreter/satisfaction logic with TxEnv struct

Author: sanket1729

examples/verify_tx.rs

@@ -20,6 +20,7 @@ use std::str::FromStr;
 
 use elements::encode::Decodable;
 use elements::{confidential, secp256k1_zkp};
+use miniscript::TxEnv;
 
 use crate::miniscript::interpreter::KeySigPair; // secp256k1 re-exported from rust-bitcoin
 fn main() {
@@ -96,12 +97,12 @@ fn main() {
     spent_utxo.value = amount;
     // Create a spend utxos, since it is a segwit spend we don't really need all prevouts. Fill dummy data for this example instead
     let utxos = [spent_utxo, elements::TxOut::default()];
-    let prevouts = elements::sighash::Prevouts::All(&utxos);
+    let env = TxEnv::new(&transaction, &utxos, 0).expect("Input len == witness utxo len");
     // segwit spends don't require genesis hash
     let genesis_hash = elements::BlockHash::default();
 
     println!("\nExample two");
-    for elem in interpreter.iter(&secp, &transaction, 0, &prevouts, genesis_hash) {
+    for elem in interpreter.iter(&secp, &env, genesis_hash) {
         match elem.expect("no evaluation error") {
             miniscript::interpreter::SatisfiedConstraint::PublicKey { key_sig } => {
                 let (key, sig) = key_sig.as_ecdsa().unwrap();
@@ -130,8 +131,7 @@ fn main() {
             ecdsa_sig.1 == elements::EcdsaSigHashType::All
                 && secp.verify_ecdsa(&message, &ecdsa_sig.0, &pk.inner).is_ok()
         }),
-        None, // tx
-        None, //prevouts
+        None, // txenv
     );
     println!("\nExample three");
     for elem in iter {

src/extensions/arith.rs

@@ -7,7 +7,7 @@ use elements::opcodes::all::*;
 use elements::sighash::Prevouts;
 use elements::{opcodes, script, Transaction};
 
-use super::{ExtParam, ParseableExt};
+use super::{ExtParam, ParseableExt, TxEnv};
 use crate::expression::{FromTree, Tree};
 use crate::miniscript::context::ScriptContextError;
 use crate::miniscript::lex::{Token as Tk, TokenIter};
@@ -908,14 +908,13 @@ impl ParseableExt for Arith {
     fn evaluate<'intp, 'txin>(
         &'intp self,
         stack: &mut interpreter::Stack<'txin>,
-        tx: Option<&Transaction>,
-        prevouts: Option<&Prevouts<'txin>>,
+        txenv: Option<&TxEnv>,
     ) -> Result<bool, interpreter::Error> {
-        let (tx, utxos) = match (tx, prevouts) {
-            (Some(tx), Some(&Prevouts::All(utxos))) => (tx, utxos),
-            _ => return Err(interpreter::Error::ArithError(EvalError::TxEnvNotPresent)),
-        };
-        match self.eval(tx, utxos) {
+        let txenv = txenv
+            .as_ref()
+            .ok_or(interpreter::Error::ArithError(EvalError::TxEnvNotPresent))?;
+
+        match self.eval(txenv.tx(), txenv.spent_utxos()) {
             Ok(true) => {
                 stack.push(interpreter::Element::Satisfied);
                 Ok(true)

src/extensions/csfs.rs

@@ -7,10 +7,9 @@ use std::str::FromStr;
 use bitcoin::hashes::hex::{FromHex, ToHex};
 use bitcoin::XOnlyPublicKey;
 use elements::hashes::hex;
-use elements::sighash::Prevouts;
-use elements::{self, opcodes, secp256k1_zkp, Transaction};
+use elements::{self, opcodes, secp256k1_zkp};
 
-use super::{ArgFromStr, CovExtArgs, ExtParam, ParseableExt};
+use super::{ArgFromStr, CovExtArgs, ExtParam, ParseableExt, TxEnv};
 use crate::miniscript::context::ScriptContextError;
 use crate::miniscript::lex::{Token as Tk, TokenIter};
 use crate::miniscript::limits::MAX_STANDARD_P2WSH_STACK_ITEM_SIZE;
@@ -275,8 +274,7 @@ impl ParseableExt for CheckSigFromStack<CovExtArgs> {
     fn evaluate<'intp, 'txin>(
         &'intp self,
         stack: &mut interpreter::Stack<'txin>,
-        _tx: Option<&Transaction>,
-        _prevouts: Option<&Prevouts<'txin>>,
+        _txenv: Option<&TxEnv>,
     ) -> Result<bool, interpreter::Error> {
         let sig = stack[0].try_push()?;
 

src/extensions/mod.rs

@@ -5,7 +5,6 @@
 use std::{fmt, hash};
 
 use elements::script::Builder;
-use elements::sighash::Prevouts;
 use elements::{Transaction, TxOut};
 
 use crate::expression::Tree;
@@ -109,8 +108,7 @@ pub trait ParseableExt:
     fn evaluate<'intp, 'txin>(
         &'intp self,
         stack: &mut Stack<'txin>,
-        tx: Option<&Transaction>,
-        prevouts: Option<&Prevouts<'txin>>,
+        txenv: Option<&TxEnv>,
     ) -> Result<bool, interpreter::Error>;
 
     /// Encoding of the current fragment
@@ -201,8 +199,7 @@ impl ParseableExt for NoExt {
     fn evaluate<'intp, 'txin>(
         &'intp self,
         _stack: &mut Stack<'txin>,
-        _tx: Option<&Transaction>,
-        _prevouts: Option<&Prevouts<'txin>>,
+        _txenv: Option<&TxEnv>,
     ) -> Result<bool, interpreter::Error> {
         match *self {}
     }
@@ -368,10 +365,9 @@ impl ParseableExt for CovenantExt<CovExtArgs> {
     fn evaluate<'intp, 'txin>(
         &self,
         stack: &mut Stack<'txin>,
-        tx: Option<&Transaction>,
-        prevouts: Option<&Prevouts<'txin>>,
+        txenv: Option<&TxEnv>,
     ) -> Result<bool, interpreter::Error> {
-        all_arms_fn!(self, ParseableExt, evaluate, stack, tx, prevouts,)
+        all_arms_fn!(self, ParseableExt, evaluate, stack, txenv,)
     }
 
     fn push_to_builder(&self, builder: Builder) -> Builder {
@@ -434,7 +430,7 @@ where
 /// being satisfied and 'ptx denotes the lifetime
 /// of the previous transaction inputs
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CovSatisfier<'tx, 'ptx> {
+pub struct TxEnv<'tx, 'ptx> {
     /// The transaction being spent
     tx: &'tx Transaction,
     /// Spent utxos
@@ -443,7 +439,7 @@ pub struct CovSatisfier<'tx, 'ptx> {
     idx: usize,
 }
 
-impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
+impl<'tx, 'ptx> TxEnv<'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() {
@@ -456,9 +452,24 @@ impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
             })
         }
     }
+
+    /// Obtains the tx
+    pub fn tx(&self) -> &Transaction {
+        self.tx
+    }
+
+    /// Obtains the spend utxos
+    pub fn spent_utxos(&self) -> &[TxOut] {
+        self.spent_utxos
+    }
+
+    /// Obtains the current input index
+    pub fn idx(&self) -> usize {
+        self.idx
+    }
 }
 
-impl<'tx, 'ptx, Pk: ToPublicKey> Satisfier<Pk> for CovSatisfier<'tx, 'ptx> {
+impl<'tx, 'ptx, Pk: ToPublicKey> Satisfier<Pk> for TxEnv<'tx, 'ptx> {
     fn lookup_tx(&self) -> Option<&elements::Transaction> {
         Some(self.tx)
     }

src/extensions/outputs_pref.rs

@@ -7,10 +7,8 @@ use std::fmt;
 use elements::encode::serialize;
 use elements::hashes::hex::{FromHex, ToHex};
 use elements::hashes::{sha256d, Hash};
-use elements::sighash::Prevouts;
-use elements::{self, Transaction};
 
-use super::{ExtParam, ParseableExt};
+use super::{ExtParam, ParseableExt, TxEnv};
 use crate::descriptor::CovError;
 use crate::miniscript::astelem::StackCtxOperations;
 use crate::miniscript::context::ScriptContextError;
@@ -246,8 +244,7 @@ impl ParseableExt for LegacyOutputsPref {
     fn evaluate<'intp, 'txin>(
         &'intp self,
         stack: &mut interpreter::Stack<'txin>,
-        _tx: Option<&Transaction>,
-        _prevouts: Option<&Prevouts<'txin>>,
+        _txenv: Option<&TxEnv>,
     ) -> Result<bool, interpreter::Error> {
         // Hash Outputs is at index 3
         let hash_outputs = stack[3];

src/extensions/tx_ver.rs

@@ -5,10 +5,8 @@
 use std::fmt;
 
 use elements::encode::serialize;
-use elements::sighash::Prevouts;
-use elements::{self, Transaction};
 
-use super::{ExtParam, ParseableExt};
+use super::{ExtParam, ParseableExt, TxEnv};
 use crate::descriptor::CovError;
 use crate::miniscript::astelem::StackCtxOperations;
 use crate::miniscript::lex::{Token as Tk, TokenIter};
@@ -169,8 +167,7 @@ impl ParseableExt for LegacyVerEq {
     fn evaluate<'intp, 'txin>(
         &'intp self,
         stack: &mut interpreter::Stack<'txin>,
-        _tx: Option<&Transaction>,
-        _prevouts: Option<&Prevouts<'txin>>,
+        _txenv: Option<&TxEnv>,
     ) -> Result<bool, interpreter::Error> {
         // Version is at index 11
         let ver = stack[11];

src/interpreter/mod.rs

@@ -24,10 +24,9 @@ use std::str::FromStr;
 
 use bitcoin;
 use elements::hashes::{hash160, ripemd160, sha256, sha256d, Hash, HashEngine};
-use elements::sighash::Prevouts;
-use elements::{self, secp256k1_zkp, sighash, EcdsaSigHashType, SigHash, Transaction};
+use elements::{self, secp256k1_zkp, sighash, EcdsaSigHashType, SigHash};
 
-use crate::extensions::{CovExtArgs, ParseableExt};
+use crate::extensions::{CovExtArgs, ParseableExt, TxEnv};
 use crate::miniscript::context::NoChecks;
 use crate::miniscript::ScriptContext;
 use crate::{util, Descriptor, ElementsSig, Miniscript, Terminal, ToPublicKey};
@@ -234,8 +233,7 @@ where
     pub fn iter_custom<'iter>(
         &'iter self,
         verify_sig: Box<dyn FnMut(&KeySigPair) -> bool + 'iter>,
-        tx: Option<&'txin Transaction>,
-        prevouts: Option<&'iter Prevouts<'txin>>,
+        txenv: Option<&'txin TxEnv<'txin, 'txin>>,
     ) -> Iter<'txin, 'iter, Ext> {
         Iter {
             verify_sig,
@@ -268,8 +266,7 @@ where
                 None
             },
             has_errored: false,
-            tx: tx,
-            prevouts: prevouts,
+            txenv: txenv,
         }
     }
 
@@ -380,21 +377,27 @@ where
     pub fn iter<'iter, C: secp256k1_zkp::Verification>(
         &'iter self,
         secp: &'iter secp256k1_zkp::Secp256k1<C>,
-        tx: &'txin elements::Transaction,
-        input_idx: usize,
-        prevouts: &'iter sighash::Prevouts<'_>, // actually a 'prevouts, but 'prevouts: 'iter
-        genesis_hash: elements::BlockHash,      // required for sighash computation in BIP341
+        txenv: &'txin TxEnv, // actually a 'prevouts, but 'prevouts: 'iter
+        genesis_hash: elements::BlockHash, // required for sighash computation in BIP341
     ) -> Iter<'txin, 'iter, Ext> {
         self.iter_custom(
-            Box::new(move |sig| self.verify_sig(secp, tx, input_idx, prevouts, genesis_hash, sig)),
-            Some(tx),
-            Some(prevouts),
+            Box::new(move |sig| {
+                self.verify_sig(
+                    secp,
+                    txenv.tx(),
+                    txenv.idx(),
+                    &sighash::Prevouts::All(txenv.spent_utxos()),
+                    genesis_hash,
+                    sig,
+                )
+            }),
+            Some(txenv),
         )
     }
 
     /// Creates an iterator over the satisfied spending conditions without checking signatures
     pub fn iter_assume_sigs<'iter>(&'iter self) -> Iter<'txin, 'iter, Ext> {
-        self.iter_custom(Box::new(|_| true), None, None)
+        self.iter_custom(Box::new(|_| true), None)
     }
 
     /// Outputs a "descriptor" string which reproduces the spent coins
@@ -626,8 +629,7 @@ where
     public_key: Option<&'intp BitcoinKey>,
     state: Vec<NodeEvaluationState<'intp, Ext>>,
     stack: Stack<'txin>,
-    tx: Option<&'txin Transaction>,
-    prevouts: Option<&'intp Prevouts<'txin>>,
+    txenv: Option<&'txin TxEnv<'txin, 'txin>>,
     age: u32,
     lock_time: u32,
     cov: Option<&'intp BitcoinKey>,
@@ -755,7 +757,7 @@ where
                     }
                 }
                 Terminal::Ext(ref ext) => {
-                    let res = ext.evaluate(&mut self.stack, self.tx, self.prevouts);
+                    let res = ext.evaluate(&mut self.stack, self.txenv);
                     match res {
                         Ok(true) => {
                             return Some(Ok(SatisfiedConstraint::Ext {
@@ -1308,8 +1310,7 @@ mod tests {
                 lock_time: 1002,
                 cov: None,
                 has_errored: false,
-                tx: None,
-                prevouts: None,
+                txenv: None,
             }
         }
 

src/lib.rs

@@ -152,7 +152,7 @@ use elements::secp256k1_zkp::Secp256k1;
 use elements::{opcodes, script, secp256k1_zkp};
 
 pub use crate::descriptor::{Descriptor, DescriptorPublicKey};
-pub use crate::extensions::{CovenantExt, Extension, NoExt};
+pub use crate::extensions::{CovenantExt, Extension, NoExt, TxEnv};
 pub use crate::interpreter::Interpreter;
 pub use crate::miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
 pub use crate::miniscript::decode::Terminal;

src/psbt/finalizer.rs

@@ -26,7 +26,7 @@ use elements::{self, confidential, Script, Transaction, TxOut};
 
 use super::{sanity_check, Error, InputError, Psbt, PsbtInputSatisfier};
 use crate::descriptor::{LegacyCSFSCov, LegacyCovSatisfier};
-use crate::extensions::{CovExtArgs, CovSatisfier};
+use crate::extensions::{CovExtArgs, TxEnv};
 use crate::{
     interpreter, util, BareCtx, CovenantExt, Descriptor, Legacy, Miniscript, MiniscriptKey,
     Satisfier, Segwitv0, Tap,
@@ -303,9 +303,10 @@ pub fn _interpreter_inp_check<C: secp256k1_zkp::Verification>(
         .map_err(|e| Error::InputError(InputError::Interpreter(e), index))?;
 
     let prevouts = prevouts(psbt)?;
-    let prevouts = elements::sighash::Prevouts::All(&prevouts);
+    let env = TxEnv::new(tx, &prevouts, index)
+        .ok_or(Error::InputError(InputError::MissingUtxo, index))?;
     if let Some(error) = interpreter
-        .iter(secp, tx, index, &prevouts, genesis_hash)
+        .iter(secp, &env, genesis_hash)
         .filter_map(Result::err)
         .next()
     {
@@ -401,7 +402,7 @@ 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)
+            let cov_sat = TxEnv::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, cov_sat), allow_mall)