Merge ElementsProject#26: Introduce 64 bit arithmetic expressions

8158647 Add CurrInp to tx value introspection (sanket1729)
1fcc865 Clean up interpreter/satisfaction logic with TxEnv struct (sanket1729)
48b47b1 Separate out new CovSatisfier from LegacySatisfier (sanket1729)
0a3a79e Add integration tests (sanket1729)
97f16a9 Introduce arithematic expressions (sanket1729)
5c91ae1 Allow interpreter to access tx and prevouts (sanket1729)
3a56d9f Change parse_num to accept generic (sanket1729)

Pull request description:

  - Adds unit and integration tests
  - Does not have integration tests for issuance/re-issuance because creating those is painful on the rust side. Please carefully review the Script translation of those fragments

ACKs for top commit:
  apoelstra:
    ACK 8158647

Tree-SHA512: 7cf8299533fdc0e03f321b5c3f544c4c513af9a36bade69f6c3434db942941c6bff8aa215b9660ad9526f0b5f94282c5922f0b092dfa75c424a17abaadb49b23

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();
@@ -124,11 +125,14 @@ 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, // txenv
+    );
     println!("\nExample three");
     for elem in iter {
         let error = elem.expect_err("evaluation error");

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,38 +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,
-        hash_type: EcdsaSigHashType,
-    ) -> Self {
-        assert!(spent_utxos.len() == tx.input.len());
-        assert!((idx as usize) < spent_utxos.len());
-        Self {
-            tx,
-            idx,
-            hash_type,
-            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(
@@ -93,7 +62,6 @@ impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
             hash_type,
             script_code: Some(script_code),
             value: Some(value),
-            spent_utxos: None,
         }
     }
 
@@ -111,7 +79,7 @@ impl<'tx, 'ptx> CovSatisfier<'tx, 'ptx> {
     }
 }
 
-impl<'tx, 'ptx, Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for CovSatisfier<'tx, 'ptx> {
+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/descriptor/sortedmulti.rs

@@ -78,7 +78,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
         if tree.args.is_empty() {
             return Err(errstr("no arguments given for sortedmulti"));
         }
-        let k = expression::parse_num(tree.args[0].name)?;
+        let k = expression::parse_num::<u32>(tree.args[0].name)?;
         if k > (tree.args.len() - 1) as u32 {
             return Err(errstr(
                 "higher threshold than there were keys in sortedmulti",

src/expression.rs

@@ -230,16 +230,23 @@ impl<'a> Tree<'a> {
 }
 
 /// Parse a string as a u32, for timelocks or thresholds
-pub fn parse_num(s: &str) -> Result<u32, Error> {
+pub fn parse_num<T: FromStr>(s: &str) -> Result<T, Error> {
     if s.len() > 1 {
         let ch = s.chars().next().unwrap();
+        let ch = if ch == '-' {
+            s.chars().nth(1).ok_or(Error::Unexpected(
+                "Negative number must follow dash sign".to_string(),
+            ))?
+        } else {
+            ch
+        };
         if !('1'..='9').contains(&ch) {
             return Err(Error::Unexpected(
                 "Number must start with a digit 1-9".to_string(),
             ));
         }
     }
-    u32::from_str(s).map_err(|_| errstr(s))
+    T::from_str(s).map_err(|_| errstr(s))
 }
 
 /// Attempts to parse a terminal expression
@@ -292,11 +299,11 @@ mod tests {
 
     #[test]
     fn test_parse_num() {
-        assert!(parse_num("0").is_ok());
-        assert!(parse_num("00").is_err());
-        assert!(parse_num("0000").is_err());
-        assert!(parse_num("06").is_err());
-        assert!(parse_num("+6").is_err());
-        assert!(parse_num("-6").is_err());
+        assert!(parse_num::<u32>("0").is_ok());
+        assert!(parse_num::<u32>("00").is_err());
+        assert!(parse_num::<u32>("0000").is_err());
+        assert!(parse_num::<u32>("06").is_err());
+        assert!(parse_num::<u32>("+6").is_err());
+        assert!(parse_num::<u32>("-6").is_err());
     }
 }