Add taproot compiler example usage

Author: SarcasticNastik

Cargo.toml

@@ -28,6 +28,7 @@ hashbrown = { version = "0.11", optional = true }
 [dev-dependencies]
 bitcoind = {version = "0.26.1", features=["22_0"]}
 actual-rand = { package = "rand", version = "0.8.4"}
+secp256k1 = {version = "0.22.1", features = ["rand-std"]}
 
 [[example]]
 name = "htlc"
@@ -52,3 +53,7 @@ required-features = ["std"]
 [[example]]
 name = "xpub_descriptors"
 required-features = ["std"]
+
+[[example]]
+name = "taproot"
+required-features = ["compiler","std"]

examples/taproot.rs

@@ -0,0 +1,100 @@
+extern crate bitcoin;
+extern crate miniscript;
+extern crate secp256k1;
+
+use std::str::FromStr;
+use std::sync::Arc;
+
+use bitcoin::util::address::WitnessVersion;
+use bitcoin::Network;
+use miniscript::descriptor::{DescriptorType, TapTree};
+use miniscript::policy::Concrete;
+use miniscript::{Descriptor, Miniscript, Tap};
+use secp256k1::{rand, KeyPair};
+
+// Refer to https://github.com/sanket1729/adv_btc_workshop/blob/master/workshop.md#creating-a-taproot-descriptor
+// for a detailed explanation of the policy and it's compilation
+
+const PUBKEY_1: &str = "5102bb3ee77f65a02d79489bebc6e6d86ffc5ff6c4a2ec2b5265a5acb4ba3106";
+const PUBKEY_2: &str = "3fc863588b1b48ec8e7a077a26112f2356a27ad4717cbb56f289f71a3740eb49";
+const PUBKEY_3: &str = "8d8ce6639a64a60c02d7d97b1b5bc4ef3b01467f306e0913c275aeb3cc9cb3dc";
+const PUBKEY_4: &str = "86fe856dc0f9adc12b863d13d03d13dec99bd1112d0425668a6f7237238aa485";
+
+fn main() {
+    let pol_str = format!(
+        "or(
+        99@thresh(2,
+            pk({}),
+            pk({})
+        ),1@or(
+            99@pk({}),
+            1@and(pk({}),
+            older(9))
+            )
+        )",
+        PUBKEY_1, PUBKEY_2, PUBKEY_3, PUBKEY_4
+    )
+    .replace(&[' ', '\n', '\t'][..], "");
+
+    let pol: Concrete<secp256k1::XOnlyPublicKey> = Concrete::from_str(&pol_str).unwrap();
+
+    // We require secp for generating a random XOnlyPublicKey
+    let secp = secp256k1::Secp256k1::new();
+    let key_pair = KeyPair::new(&secp, &mut rand::thread_rng());
+    // Random unspendable XOnlyPublicKey provided for compilation to Taproot Descriptor
+    let unspendable_key = secp256k1::XOnlyPublicKey::from_keypair(&key_pair);
+
+    let private_desc = pol
+        .compile_tr_private(Some(unspendable_key.clone()))
+        .unwrap();
+    // println!("{:}", private_desc);
+    // let opt_desc = pol.compile_tr(Some(unspendable_key.clone())).unwrap();
+    // println!("{:}", opt_desc);
+
+    // Check whether the descriptors are safe.
+    assert!(private_desc.sanity_check().is_ok());
+    // assert!(opt_desc.sanity_check().is_ok());
+
+    // Descriptor Type and Version should match respectively for Taproot
+    let priv_desc_type = private_desc.desc_type();
+    assert_eq!(priv_desc_type, DescriptorType::Tr);
+    // let opt_desc_type = opt_desc.desc_type();
+    // assert_eq!(opt_desc_type, DescriptorType::Tr);
+    assert_eq!(priv_desc_type.segwit_version().unwrap(), WitnessVersion::V1);
+    // assert_eq!(opt_desc_type.segwit_version().unwrap(), WitnessVersion::V1);
+
+    // Compute the bitcoin address and check if it matches
+    let network = Network::Bitcoin;
+    let priv_addr = private_desc.address(network).unwrap();
+    let expected_addr = bitcoin::Address::from_str(
+        "bc1p0y6a05cz95qhj6wlt5fuw7ykh5pq7580hsjkt7tdnd4y8tfv5g0s2w60nu",
+    )
+    .unwrap();
+    assert_eq!(priv_addr, expected_addr);
+
+    // Computing the underlying script should fail for Taproot Descriptor
+    assert!(private_desc.explicit_script().is_err());
+
+    // Max Satisfaction Weight for compilation, corresponding to the script-path spend
+    // `multi_a(2,PUBKEY_1,PUBKEY_2) at taptree depth 1, having
+    // Max Witness Size = scriptSig len + control_block size + varint(script_size) + script_size +
+    //                     varint(max satisfaction elements) + max satisfaction size
+    //                  = 4 + 65 + 1 + 70 + 1 + 132
+    let max_sat_wt = private_desc.max_satisfaction_weight().unwrap();
+    assert_eq!(max_sat_wt, 273);
+
+    if let Descriptor::Tr(p) = private_desc {
+        // Check if internal key is correctly inferred as PUBKEY_3
+        assert_eq!(format!("{}", p.internal_key()), PUBKEY_3);
+
+        // Check if the constructed TapTree is correctly built
+        let expected_taptree: TapTree<bitcoin::XOnlyPublicKey> = TapTree::Tree(
+            Arc::new(TapTree::Leaf(Arc::new(Miniscript::<bitcoin::XOnlyPublicKey, Tap>::from_str_insane("and_v(v:pk(86fe856dc0f9adc12b863d13d03d13dec99bd1112d0425668a6f7237238aa485),older(9))").unwrap()))),
+            Arc::new(TapTree::Leaf(Arc::new(Miniscript::<bitcoin::XOnlyPublicKey, Tap>::from_str_insane("multi_a(2,5102bb3ee77f65a02d79489bebc6e6d86ffc5ff6c4a2ec2b5265a5acb4ba3106,3fc863588b1b48ec8e7a077a26112f2356a27ad4717cbb56f289f71a3740eb49)").unwrap()))),
+        );
+        assert_eq!(
+            p.taptree().clone().expect("TapTree expected"),
+            expected_taptree
+        );
+    }
+}