Update interpreter API in psbt

Author: sanket1729

src/psbt/finalizer.rs

@@ -19,10 +19,9 @@
 //! `https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki`
 //!
 
+use bitcoin::util::sighash::Prevouts;
 use util::{script_is_v1_tr, witness_size};
 
-use interpreter::KeySigPair;
-
 use super::{sanity_check, Psbt};
 use super::{Error, InputError, PsbtInputSatisfier};
 use bitcoin::blockdata::witness::Witness;
@@ -99,32 +98,31 @@ fn construct_tap_witness(
 
 // Get the scriptpubkey for the psbt input
 fn get_scriptpubkey(psbt: &Psbt, index: usize) -> Result<&Script, InputError> {
-    let script_pubkey;
-    let inp = &psbt.inputs[index];
-    if let Some(ref witness_utxo) = inp.witness_utxo {
-        script_pubkey = &witness_utxo.script_pubkey;
-    } else if let Some(ref non_witness_utxo) = inp.non_witness_utxo {
-        let vout = psbt.unsigned_tx.input[index].previous_output.vout;
-        script_pubkey = &non_witness_utxo.output[vout as usize].script_pubkey;
-    } else {
-        return Err(InputError::MissingUtxo);
-    }
-    Ok(script_pubkey)
+    get_utxo(psbt, index).map(|utxo| &utxo.script_pubkey)
 }
 
-// Get the amount being spent for the psbt input
-fn get_amt(psbt: &Psbt, index: usize) -> Result<u64, InputError> {
-    let amt;
+// Get the spending utxo for this psbt input
+fn get_utxo(psbt: &Psbt, index: usize) -> Result<&bitcoin::TxOut, InputError> {
     let inp = &psbt.inputs[index];
-    if let Some(ref witness_utxo) = inp.witness_utxo {
-        amt = witness_utxo.value;
+    let utxo = if let Some(ref witness_utxo) = inp.witness_utxo {
+        &witness_utxo
     } else if let Some(ref non_witness_utxo) = inp.non_witness_utxo {
         let vout = psbt.unsigned_tx.input[index].previous_output.vout;
-        amt = non_witness_utxo.output[vout as usize].value;
+        &non_witness_utxo.output[vout as usize]
     } else {
         return Err(InputError::MissingUtxo);
+    };
+    Ok(utxo)
+}
+
+/// Get the Prevouts for the psbt
+fn prevouts<'a>(psbt: &'a Psbt) -> Result<Vec<bitcoin::TxOut>, super::Error> {
+    let mut utxos = vec![];
+    for i in 0..psbt.inputs.len() {
+        let utxo_ref = get_utxo(psbt, i).map_err(|e| Error::InputError(e, i))?;
+        utxos.push(utxo_ref.clone()); // RC fix would allow references here instead of clone
     }
-    Ok(amt)
+    Ok(utxos)
 }
 
 // Create a descriptor from unfinalized PSBT input.
@@ -284,6 +282,8 @@ pub fn interpreter_check<C: secp256k1::Verification>(
     psbt: &Psbt,
     secp: &Secp256k1<C>,
 ) -> Result<(), Error> {
+    let utxos = prevouts(&psbt)?;
+    let utxos = &Prevouts::All(&utxos);
     for (index, input) in psbt.inputs.iter().enumerate() {
         let spk = get_scriptpubkey(psbt, index).map_err(|e| Error::InputError(e, index))?;
         let empty_script_sig = Script::new();
@@ -297,23 +297,14 @@ pub fn interpreter_check<C: secp256k1::Verification>(
 
         // Now look at all the satisfied constraints. If everything is filled in
         // corrected, there should be no errors
-
-        let cltv = psbt.unsigned_tx.lock_time;
-        let csv = psbt.unsigned_tx.input[index].sequence;
-        let _amt = get_amt(psbt, index).map_err(|e| Error::InputError(e, index))?;
-        // let vfyfn = interpreter
-        //     .sighash_verify(&secp, &psbt.unsigned_tx, index, amt)
-        //     .map_err(|e| Error::InputError(InputError::Interpreter(e), index))?;
-        // Will change in later commmit
+        // Interpreter check
         {
+            let cltv = psbt.unsigned_tx.lock_time;
+            let csv = psbt.unsigned_tx.input[index].sequence;
             let interpreter =
                 interpreter::Interpreter::from_txdata(spk, &script_sig, &witness, cltv, csv)
                     .map_err(|e| Error::InputError(InputError::Interpreter(e), index))?;
-            let y = |_x: &KeySigPair| {
-                secp.ctx();
-                true
-            };
-            let iter = interpreter.iter_custom(Box::new(y));
+            let iter = interpreter.iter(secp, &psbt.unsigned_tx, index, &utxos);
             if let Some(error) = iter.filter_map(Result::err).next() {
                 return Err(Error::InputError(InputError::Interpreter(error), index));
             };