Add taproot tests

Also update block count in generatetoaddress for fast execution of
integration tests

Author: sanket1729

integration_test/src/main.rs

@@ -10,8 +10,8 @@ extern crate miniscript;
 
 use bitcoincore_rpc::{Auth, Client, RpcApi};
 
-mod test_desc;
 mod test_cpp;
+mod test_desc;
 mod test_util;
 use test_util::TestData;
 
@@ -68,4 +68,62 @@ fn main() {
 
     let testdata = TestData::new_fixed_data(50);
     test_cpp::test_from_cpp_ms(&cl, &testdata);
+
+    test_descs(&cl, &testdata);
+}
+
+fn test_descs(cl: &Client, testdata: &TestData) {
+    // K : Compressed key available
+    // K!: Compressed key with corresponding secret key unknown
+    // X: X-only key available
+    // X!: X-only key with corresponding secret key unknown
+
+    // Test 1: Simple spend with internal key
+    let wit = test_desc::test_desc_satisfy(cl, testdata, "tr(X)");
+    assert!(wit.len() == 1);
+
+    // Test 2: Same as above, but with leaves
+    let wit = test_desc::test_desc_satisfy(cl, testdata, "tr(X,{pk(X1!),pk(X2!)})");
+    assert!(wit.len() == 1);
+
+    // Test 3: Force to spend with script spend. Unknown internal key and only one known script path
+    // X! -> Internal key unknown
+    // Leaf 1 -> pk(X1) with X1 known
+    // Leaf 2-> and_v(v:pk(X2),pk(X3!)) with partial witness only to X2 known
+    let wit = test_desc::test_desc_satisfy(cl, testdata, "tr(X!,{pk(X1),and_v(v:pk(X2),pk(X3!))})");
+    assert!(wit.len() == 3); // control block, script and signature
+
+    // Test 4: Force to spend with script spend. Unknown internal key and multiple script paths
+    // Should select the one with minimum weight
+    // X! -> Internal key unknown
+    // Leaf 1 -> pk(X1!) with X1 unknown
+    // Leaf 2-> and_v(v:pk(X2),pk(X3)) X2 and X3 known
+    let wit = test_desc::test_desc_satisfy(cl, testdata, "tr(X!,{pk(X1),and_v(v:pk(X2),pk(X3))})");
+    assert!(wit.len() == 3); // control block, script and one signatures
+
+    // Test 5: When everything is available, we should select the key spend path
+    let wit = test_desc::test_desc_satisfy(cl, testdata, "tr(X,{pk(X1),and_v(v:pk(X2),pk(X3!))})");
+    assert!(wit.len() == 1); // control block, script and signature
+
+    // Test 6: Test the new multi_a opcodes
+    test_desc::test_desc_satisfy(cl, testdata, "tr(X!,{pk(X1!),multi_a(1,X2,X3!,X4!,X5!)})");
+    test_desc::test_desc_satisfy(cl, testdata, "tr(X!,{pk(X1!),multi_a(2,X2,X3,X4!,X5!)})");
+    test_desc::test_desc_satisfy(cl, testdata, "tr(X!,{pk(X1!),multi_a(3,X2,X3,X4,X5!)})");
+    test_desc::test_desc_satisfy(cl, testdata, "tr(X!,{pk(X1!),multi_a(4,X2,X3,X4,X5)})");
+
+    // Misc tests for other descriptors that we support
+    // Keys
+    test_desc::test_desc_satisfy(cl, testdata, "wpkh(K)");
+    test_desc::test_desc_satisfy(cl, testdata, "pkh(K)");
+    test_desc::test_desc_satisfy(cl, testdata, "sh(wpkh(K))");
+
+    // sorted multi
+    test_desc::test_desc_satisfy(cl, testdata, "sh(sortedmulti(2,K1,K2,K3))");
+    test_desc::test_desc_satisfy(cl, testdata, "wsh(sortedmulti(2,K1,K2,K3))");
+    test_desc::test_desc_satisfy(cl, testdata, "sh(wsh(sortedmulti(2,K1,K2,K3)))");
+
+    // Miniscripts
+    test_desc::test_desc_satisfy(cl, testdata, "sh(and_v(v:pk(K1),pk(K2)))");
+    test_desc::test_desc_satisfy(cl, testdata, "wsh(and_v(v:pk(K1),pk(K2)))");
+    test_desc::test_desc_satisfy(cl, testdata, "sh(wsh(and_v(v:pk(K1),pk(K2))))");
 }

integration_test/src/test_desc.rs

@@ -13,7 +13,7 @@ use bitcoin::util::{psbt, sighash};
 use bitcoin::{self, Amount, OutPoint, SchnorrSig, Script, Transaction, TxIn, TxOut, Txid};
 use bitcoincore_rpc::{json, Client, RpcApi};
 use miniscript::miniscript::iter;
-use miniscript::psbt::PbstOps;
+use miniscript::psbt::PsbtExt;
 use miniscript::{Descriptor, DescriptorTrait, Miniscript, ToPublicKey};
 use miniscript::{MiniscriptKey, ScriptContext};
 use std::collections::BTreeMap;
@@ -40,17 +40,17 @@ fn get_vout(cl: &Client, txid: Txid, value: u64, spk: Script) -> (OutPoint, TxOu
     unreachable!("Only call get vout on functions which have the expected outpoint");
 }
 
-pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witness {
+pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: &str) -> Witness {
     let secp = secp256k1::Secp256k1::new();
     let sks = &testdata.secretdata.sks;
     let xonly_keypairs = &testdata.secretdata.x_only_keypairs;
     let pks = &testdata.pubdata.pks;
     let x_only_pks = &testdata.pubdata.x_only_pks;
     // Generate some blocks
     let blocks = cl
-        .generate_to_address(500, &cl.get_new_address(None, None).unwrap())
+        .generate_to_address(1, &cl.get_new_address(None, None).unwrap())
         .unwrap();
-    assert_eq!(blocks.len(), 500);
+    assert_eq!(blocks.len(), 1);
 
     let desc = test_util::parse_test_desc(&desc, &testdata.pubdata);
     let derived_desc = desc.derived_descriptor(&secp, 0).unwrap();
@@ -69,9 +69,9 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
         .unwrap();
     // Wait for the funds to mature.
     let blocks = cl
-        .generate_to_address(50, &cl.get_new_address(None, None).unwrap())
+        .generate_to_address(2, &cl.get_new_address(None, None).unwrap())
         .unwrap();
-    assert_eq!(blocks.len(), 50);
+    assert_eq!(blocks.len(), 2);
     // Create a PSBT for each transaction.
     // Spend one input and spend one output for simplicity.
     let mut psbt = Psbt {
@@ -95,8 +95,8 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
     txin.previous_output = outpoint;
     // set the sequence to a non-final number for the locktime transactions to be
     // processed correctly.
-    // We waited 50 blocks, keep 49 for safety
-    txin.sequence = 49;
+    // We waited 2 blocks, keep 1 for safety
+    txin.sequence = 1;
     psbt.unsigned_tx.input.push(txin);
     // Get a new script pubkey from the node so that
     // the node wallet tracks the receiving transaction
@@ -112,7 +112,7 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
     input.witness_utxo = Some(witness_utxo.clone());
     psbt.inputs.push(input);
     psbt.outputs.push(psbt::Output::default());
-    psbt.update_desc(0, &desc, 0..0).unwrap();
+    psbt.update_desc(0, &desc, None).unwrap();
 
     // --------------------------------------------
     // Sign the transactions with all keys
@@ -134,7 +134,9 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
 
             if let Some(mut internal_keypair) = internal_keypair {
                 // ---------------------- Tr key spend --------------------
-                internal_keypair.tweak_add_assign(&secp, tr.spend_info().tap_tweak().as_ref());
+                internal_keypair
+                    .tweak_add_assign(&secp, tr.spend_info().tap_tweak().as_ref())
+                    .expect("Tweaking failed");
                 let sighash_msg = sighash_cache
                     .taproot_key_spend_signature_hash(0, &prevouts, hash_ty)
                     .unwrap();
@@ -218,7 +220,10 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
                 },
                 Descriptor::Tr(_tr) => unreachable!("Tr checked earlier"),
             };
-            let msg = psbt.sighash_msg(0, &mut sighash_cache, None).unwrap().to_secp_msg();
+            let msg = psbt
+                .sighash_msg(0, &mut sighash_cache, None)
+                .unwrap()
+                .to_secp_msg();
 
             // Fixme: Take a parameter
             let hash_ty = bitcoin::EcdsaSigHashType::All;
@@ -227,6 +232,7 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
             for sk in sks_reqd {
                 let sig = secp.sign_ecdsa(&msg, &sk);
                 let pk = pks[sks.iter().position(|&x| x == sk).unwrap()];
+                assert!(secp.verify_ecdsa(&msg, &sig, &pk.inner).is_ok());
                 psbt.inputs[0].partial_sigs.insert(
                     pk.inner,
                     bitcoin::EcdsaSig {
@@ -257,9 +263,12 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
     println!("Testing descriptor: {}", desc);
     // Finalize the transaction using psbt
     // Let miniscript do it's magic!
-    if let Err(e) = psbt.finalize(&secp) {
+    if let Err(e) = psbt.finalize_mut(&secp) {
         // All miniscripts should satisfy
-        panic!("Could not satisfy non-malleably: error{} desc:{} ", e, desc);
+        panic!(
+            "Could not satisfy non-malleably: error{} desc:{} ",
+            e[0], desc
+        );
     }
     let tx = psbt.extract(&secp).expect("Extraction error");
 
@@ -272,7 +281,7 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: String) -> Witn
 
     // Finally mine the blocks and await confirmations
     let _blocks = cl
-        .generate_to_address(10, &cl.get_new_address(None, None).unwrap())
+        .generate_to_address(1, &cl.get_new_address(None, None).unwrap())
         .unwrap();
     // Get the required transactions from the node mined in the blocks.
     // Check whether the transaction is mined in blocks
@@ -310,8 +319,6 @@ fn find_sks_ms<Ctx: ScriptContext>(
 fn find_sk_single_key(pk: bitcoin::PublicKey, testdata: &TestData) -> Vec<secp256k1::SecretKey> {
     let sks = &testdata.secretdata.sks;
     let pks = &testdata.pubdata.pks;
-    let i = pks
-        .iter()
-        .position(|&x| x.to_public_key() == pk);
+    let i = pks.iter().position(|&x| x.to_public_key() == pk);
     i.map(|idx| vec![sks[idx]]).unwrap_or(Vec::new())
 }