Allow interpreter to access tx and prevouts

update extension interpreter API

Author: sanket1729

examples/verify_tx.rs

@@ -124,11 +124,15 @@ fn main() {
     )
     .unwrap();
 
-    let iter = interpreter.iter_custom(Box::new(|key_sig: &KeySigPair| {
-        let (pk, ecdsa_sig) = key_sig.as_ecdsa().expect("Ecdsa Sig");
-        ecdsa_sig.1 == elements::EcdsaSigHashType::All
-            && secp.verify_ecdsa(&message, &ecdsa_sig.0, &pk.inner).is_ok()
-    }));
+    let iter = interpreter.iter_custom(
+        Box::new(|key_sig: &KeySigPair| {
+            let (pk, ecdsa_sig) = key_sig.as_ecdsa().expect("Ecdsa Sig");
+            ecdsa_sig.1 == elements::EcdsaSigHashType::All
+                && secp.verify_ecdsa(&message, &ecdsa_sig.0, &pk.inner).is_ok()
+        }),
+        None, // tx
+        None, //prevouts
+    );
     println!("\nExample three");
     for elem in iter {
         let error = elem.expect_err("evaluation error");

src/extensions/csfs.rs

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

src/extensions/mod.rs

@@ -5,6 +5,8 @@
 use std::{fmt, hash};
 
 use elements::script::Builder;
+use elements::sighash::Prevouts;
+use elements::Transaction;
 
 use crate::expression::Tree;
 use crate::interpreter::{self, Stack};
@@ -104,6 +106,8 @@ pub trait ParseableExt:
     fn evaluate<'intp, 'txin>(
         &'intp self,
         stack: &mut Stack<'txin>,
+        tx: Option<&Transaction>,
+        prevouts: Option<&Prevouts<'txin>>,
     ) -> Result<bool, interpreter::Error>;
 
     /// Encoding of the current fragment
@@ -194,6 +198,8 @@ impl ParseableExt for NoExt {
     fn evaluate<'intp, 'txin>(
         &'intp self,
         _stack: &mut Stack<'txin>,
+        _tx: Option<&Transaction>,
+        _prevouts: Option<&Prevouts<'txin>>,
     ) -> Result<bool, interpreter::Error> {
         match *self {}
     }
@@ -351,8 +357,13 @@ impl ParseableExt for CovenantExt<CovExtArgs> {
         all_arms_fn!(self, ParseableExt, dissatisfy, sat,)
     }
 
-    fn evaluate(&self, stack: &mut Stack) -> Result<bool, interpreter::Error> {
-        all_arms_fn!(self, ParseableExt, evaluate, stack,)
+    fn evaluate<'intp, 'txin>(
+        &self,
+        stack: &mut Stack<'txin>,
+        tx: Option<&Transaction>,
+        prevouts: Option<&Prevouts<'txin>>,
+    ) -> Result<bool, interpreter::Error> {
+        all_arms_fn!(self, ParseableExt, evaluate, stack, tx, prevouts,)
     }
 
     fn push_to_builder(&self, builder: Builder) -> Builder {

src/extensions/outputs_pref.rs

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

src/extensions/tx_ver.rs

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

src/interpreter/mod.rs

@@ -24,7 +24,8 @@ use std::str::FromStr;
 
 use bitcoin;
 use elements::hashes::{hash160, ripemd160, sha256, sha256d, Hash, HashEngine};
-use elements::{self, secp256k1_zkp, sighash, EcdsaSigHashType, SigHash};
+use elements::sighash::Prevouts;
+use elements::{self, secp256k1_zkp, sighash, EcdsaSigHashType, SigHash, Transaction};
 
 use crate::extensions::{CovExtArgs, ParseableExt};
 use crate::miniscript::context::NoChecks;
@@ -233,6 +234,8 @@ 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>>,
     ) -> Iter<'txin, 'iter, Ext> {
         Iter {
             verify_sig,
@@ -265,6 +268,8 @@ where
                 None
             },
             has_errored: false,
+            tx: tx,
+            prevouts: prevouts,
         }
     }
 
@@ -380,14 +385,16 @@ where
         prevouts: &'iter sighash::Prevouts<'_>, // 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)
-        }))
+        self.iter_custom(
+            Box::new(move |sig| self.verify_sig(secp, tx, input_idx, prevouts, genesis_hash, sig)),
+            Some(tx),
+            Some(prevouts),
+        )
     }
 
     /// 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))
+        self.iter_custom(Box::new(|_| true), None, None)
     }
 
     /// Outputs a "descriptor" string which reproduces the spent coins
@@ -619,6 +626,8 @@ where
     public_key: Option<&'intp BitcoinKey>,
     state: Vec<NodeEvaluationState<'intp, Ext>>,
     stack: Stack<'txin>,
+    tx: Option<&'txin Transaction>,
+    prevouts: Option<&'intp Prevouts<'txin>>,
     age: u32,
     lock_time: u32,
     cov: Option<&'intp BitcoinKey>,
@@ -746,7 +755,7 @@ where
                     }
                 }
                 Terminal::Ext(ref ext) => {
-                    let res = ext.evaluate(&mut self.stack);
+                    let res = ext.evaluate(&mut self.stack, self.tx, self.prevouts);
                     match res {
                         Ok(true) => {
                             return Some(Ok(SatisfiedConstraint::Ext {
@@ -1288,17 +1297,19 @@ mod tests {
         ) -> Iter<'elem, 'txin, NoExt> {
             Iter {
                 verify_sig: verify_fn,
-                stack: stack,
                 public_key: None,
                 state: vec![NodeEvaluationState {
                     node: &ms,
                     n_evaluated: 0,
                     n_satisfied: 0,
                 }],
+                stack: stack,
                 age: 1002,
                 lock_time: 1002,
                 cov: None,
                 has_errored: false,
+                tx: None,
+                prevouts: None,
             }
         }