Update ToPublicKey API to take in context param

Author: sanket1729

examples/htlc.rs

@@ -20,6 +20,7 @@ extern crate miniscript;
 use bitcoin::Network;
 use miniscript::policy::{Concrete, Liftable};
 use miniscript::Descriptor;
+use miniscript::NullCtx;
 use std::str::FromStr;
 
 fn main() {
@@ -44,17 +45,20 @@ fn main() {
     );
 
     assert_eq!(
-        format!("{:x}", htlc_descriptor.script_pubkey()),
+        format!("{:x}", htlc_descriptor.script_pubkey(NullCtx)),
         "00203c0a59874cb570ff3093bcd67e846c967127c9e3fcd30f0a20857b504599e50a"
     );
 
     assert_eq!(
-        format!("{:x}", htlc_descriptor.witness_script()),
+        format!("{:x}", htlc_descriptor.witness_script(NullCtx)),
         "21022222222222222222222222222222222222222222222222222222222222222222ac6476a9144377a5acd66dc5cb67148a24818d1e51fa183bd288ad025c11b26782012088a82011111111111111111111111111111111111111111111111111111111111111118768"
     );
 
     assert_eq!(
-        format!("{}", htlc_descriptor.address(Network::Bitcoin).unwrap()),
+        format!(
+            "{}",
+            htlc_descriptor.address(Network::Bitcoin, NullCtx).unwrap()
+        ),
         "bc1q8s99np6vk4c07vynhnt8aprvjecj0j0rlnfs7z3qs4a4q3veu59q8x3k8x"
     );
 }

examples/parse.rs

@@ -17,6 +17,7 @@
 extern crate bitcoin;
 extern crate miniscript;
 
+use miniscript::NullCtx;
 use std::str::FromStr;
 
 fn main() {
@@ -25,13 +26,17 @@ fn main() {
     )
     .unwrap();
 
+    // Sometimes it is necesarry to have additional information to get the bitcoin::PublicKey
+    // from the MiniscriptKey which can supplied by `to_pk_ctx` parameter. For example,
+    // when calculating the script pubkey of a descriptor with xpubs, the secp context and
+    // child information maybe required.
     assert_eq!(
-        format!("{:x}", my_descriptor.script_pubkey()),
+        format!("{:x}", my_descriptor.script_pubkey(NullCtx)),
         "0020daef16dd7c946a3e735a6e43310cb2ce33dfd14a04f76bf8241a16654cb2f0f9"
     );
 
     assert_eq!(
-        format!("{:x}", my_descriptor.witness_script()),
+        format!("{:x}", my_descriptor.witness_script(NullCtx)),
         "21020202020202020202020202020202020202020202020202020202020202020202ac"
     );
 }

examples/sign_multisig.rs

@@ -18,6 +18,7 @@ extern crate bitcoin;
 extern crate miniscript;
 
 use bitcoin::secp256k1; // secp256k1 re-exported from rust-bitcoin
+use miniscript::NullCtx;
 use std::collections::HashMap;
 use std::str::FromStr;
 
@@ -82,19 +83,24 @@ fn main() {
     let my_descriptor =
         BitcoinDescriptor::from_str(&descriptor_str[..]).expect("parse descriptor string");
 
+    // Sometimes it is necesarry to have additional information to get the bitcoin::PublicKey
+    // from the MiniscriptKey which can supplied by `to_pk_ctx` parameter. For example,
+    // when calculating the script pubkey of a descriptor with xpubs, the secp context and
+    // child information maybe required.
+
     // Check weight for witness satisfaction cost ahead of time.
     // 4(scriptSig length of 0) + 1(witness stack size) + 106(serialized witnessScript)
     // + 73*2(signature length + signatures + sighash bytes) + 1(dummy byte) = 258
-    assert_eq!(my_descriptor.max_satisfaction_weight().unwrap(), 258);
+    assert_eq!(my_descriptor.max_satisfaction_weight(NullCtx).unwrap(), 258);
 
     // Observe the script properties, just for fun
     assert_eq!(
-        format!("{:x}", my_descriptor.script_pubkey()),
+        format!("{:x}", my_descriptor.script_pubkey(NullCtx)),
         "00200ed49b334a12c37f3df8a2974ad91ff95029215a2b53f78155be737907f06163"
     );
 
     assert_eq!(
-        format!("{:x}", my_descriptor.witness_script()),
+        format!("{:x}", my_descriptor.witness_script(NullCtx)),
         "52\
          21020202020202020202020202020202020202020202020202020202020202020202\
          21020102030405060708010203040506070801020304050607080000000000000000\
@@ -108,23 +114,31 @@ fn main() {
     let mut sigs = HashMap::<bitcoin::PublicKey, miniscript::BitcoinSig>::new();
 
     // Doesn't work with no signatures
-    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_err());
+    assert!(my_descriptor
+        .satisfy(&mut tx.input[0], &sigs, NullCtx)
+        .is_err());
     assert_eq!(tx.input[0], original_txin);
 
     // ...or one signature...
     sigs.insert(public_keys[1], bitcoin_sig);
-    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_err());
+    assert!(my_descriptor
+        .satisfy(&mut tx.input[0], &sigs, NullCtx)
+        .is_err());
     assert_eq!(tx.input[0], original_txin);
 
     // ...but two signatures is ok
     sigs.insert(public_keys[2], bitcoin_sig);
-    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_ok());
+    assert!(my_descriptor
+        .satisfy(&mut tx.input[0], &sigs, NullCtx)
+        .is_ok());
     assert_ne!(tx.input[0], original_txin);
     assert_eq!(tx.input[0].witness.len(), 4); // 0, sig, sig, witness script
 
     // ...and even if we give it a third signature, only two are used
     sigs.insert(public_keys[0], bitcoin_sig);
-    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_ok());
+    assert!(my_descriptor
+        .satisfy(&mut tx.input[0], &sigs, NullCtx)
+        .is_ok());
     assert_ne!(tx.input[0], original_txin);
     assert_eq!(tx.input[0].witness.len(), 4); // 0, sig, sig, witness script
 }

examples/verify_tx.rs

@@ -19,7 +19,7 @@ extern crate miniscript;
 
 use bitcoin::consensus::Decodable;
 use bitcoin::secp256k1; // secp256k1 re-exported from rust-bitcoin
-
+use miniscript::NullCtx;
 fn main() {
     // tx `f27eba163c38ad3f34971198687a3f1882b7ec818599ffe469a8440d82261c98`
     #[cfg_attr(feature="cargo-fmt", rustfmt_skip)]
@@ -116,7 +116,11 @@ fn main() {
     // 2. Example two: verify the signatures to ensure that invalid
     //    signatures are not treated as having participated in the script
     let secp = secp256k1::Secp256k1::new();
-    let sighash = transaction.signature_hash(0, &desc.witness_script(), 1);
+    // Sometimes it is necesarry to have additional information to get the bitcoin::PublicKey
+    // from the MiniscriptKey which can supplied by `to_pk_ctx` parameter. For example,
+    // when calculating the script pubkey of a descriptor with xpubs, the secp context and
+    // child information maybe required.
+    let sighash = transaction.signature_hash(0, &desc.witness_script(NullCtx), 1);
     let message = secp256k1::Message::from_slice(&sighash[..]).expect("32-byte hash");
 
     let iter = miniscript::descriptor::SatisfiedConstraints::from_descriptor(

fuzz/fuzz_targets/roundtrip_miniscript_script.rs

@@ -2,15 +2,16 @@ extern crate miniscript;
 
 use miniscript::bitcoin::blockdata::script;
 use miniscript::Miniscript;
+use miniscript::NullCtx;
 use miniscript::Segwitv0;
 
 fn do_test(data: &[u8]) {
     // Try round-tripping as a script
     let script = script::Script::from(data.to_owned());
 
     if let Ok(pt) = Miniscript::<_, Segwitv0>::parse(&script) {
-        let output = pt.encode();
-        assert_eq!(pt.script_size(), output.len());
+        let output = pt.encode(NullCtx);
+        assert_eq!(pt.script_size(NullCtx), output.len());
         assert_eq!(output, script);
     }
 }

src/descriptor/create_descriptor.rs

@@ -11,6 +11,7 @@ use descriptor::satisfied_constraints::{Stack, StackElement};
 use descriptor::Descriptor;
 use miniscript::{Legacy, Miniscript, Segwitv0};
 use Error;
+use NullCtx;
 use ToPublicKey;
 
 /// Helper function for creating StackElement from Push instructions. Special case required for
@@ -89,8 +90,9 @@ fn verify_p2wpkh<'txin>(
     }
     if let Some((pk_bytes, witness)) = witness.split_last() {
         if let Ok(pk) = bitcoin::PublicKey::from_slice(pk_bytes) {
-            let addr = bitcoin::Address::p2wpkh(&pk.to_public_key(), bitcoin::Network::Bitcoin)
-                .map_err(|_| Error::InterpreterError(IntError::UncompressedPubkey))?;
+            let addr =
+                bitcoin::Address::p2wpkh(&pk.to_public_key(NullCtx), bitcoin::Network::Bitcoin)
+                    .map_err(|_| Error::InterpreterError(IntError::UncompressedPubkey))?;
             if addr.script_pubkey() != *script_pubkey {
                 return Err(Error::InterpreterError(IntError::PkEvaluationError(pk)));
             }
@@ -145,7 +147,7 @@ fn verify_p2pkh<'txin>(
 ) -> Result<(Descriptor<bitcoin::PublicKey>, Stack<'txin>), Error> {
     let (pk_bytes, stack) = parse_scriptsig_top(script_sig)?;
     if let Ok(pk) = bitcoin::PublicKey::from_slice(&pk_bytes) {
-        let addr = bitcoin::Address::p2pkh(&pk.to_public_key(), bitcoin::Network::Bitcoin);
+        let addr = bitcoin::Address::p2pkh(&pk.to_public_key(NullCtx), bitcoin::Network::Bitcoin);
         if !witness.is_empty() {
             return Err(Error::NonEmptyWitness);
         }
@@ -247,7 +249,7 @@ mod tests {
     use descriptor::satisfied_constraints::{Stack, StackElement};
     use std::str::FromStr;
     use ToPublicKey;
-    use {Descriptor, Miniscript};
+    use {Descriptor, Miniscript, NullCtx};
 
     macro_rules! stack {
         ($($data:ident$(($pushdata:expr))*),*) => (
@@ -309,7 +311,7 @@ mod tests {
 
         //test pk
         let script_pubkey = script::Builder::new()
-            .push_key(&pks[0].to_public_key())
+            .push_key(&pks[0].to_public_key(NullCtx))
             .push_opcode(opcodes::all::OP_CHECKSIG)
             .into_script();
         let script_sig = script::Builder::new().push_slice(&sigs[0]).into_script();
@@ -334,17 +336,21 @@ mod tests {
         //test Wsh: and(pkv, pk). Note this does not check miniscript.
         let ms = ms_str!("and_v(vc:pk_k({}),c:pk_k({}))", pks[0], pks[1]);
         let script_pubkey =
-            bitcoin::Address::p2wsh(&ms.encode(), bitcoin::Network::Bitcoin).script_pubkey();
+            bitcoin::Address::p2wsh(&ms.encode(NullCtx), bitcoin::Network::Bitcoin).script_pubkey();
         let script_sig = script::Builder::new().into_script();
-        let witness = vec![sigs[1].clone(), sigs[0].clone(), ms.encode().to_bytes()];
+        let witness = vec![
+            sigs[1].clone(),
+            sigs[0].clone(),
+            ms.encode(NullCtx).to_bytes(),
+        ];
         let (des, stack) = from_txin_with_witness_stack(&script_pubkey, &script_sig, &witness)
             .expect("Descriptor/Witness stack creation to succeed");
         assert_eq!(Descriptor::Wsh(ms.clone()), des);
         assert_eq!(stack, stack![Push(&sigs[1]), Push(&sigs[0])]);
 
         //test Bare: and(pkv, pk). Note this does not check miniscript.
         let ms = ms_str!("or_b(c:pk_k({}),sc:pk_k({}))", pks[0], pks[1]);
-        let script_pubkey = ms.encode();
+        let script_pubkey = ms.encode(NullCtx);
         let script_sig = script::Builder::new()
             .push_int(0)
             .push_slice(&sigs[0])
@@ -358,11 +364,11 @@ mod tests {
         //test Sh: and(pkv, pk). Note this does not check miniscript.
         let ms = ms_str!("c:or_i(pk_k({}),pk_k({}))", pks[0], pks[1]);
         let script_pubkey =
-            bitcoin::Address::p2sh(&ms.encode(), bitcoin::Network::Bitcoin).script_pubkey();
+            bitcoin::Address::p2sh(&ms.encode(NullCtx), bitcoin::Network::Bitcoin).script_pubkey();
         let script_sig = script::Builder::new()
             .push_slice(&sigs[0])
             .push_int(1)
-            .push_slice(&ms.encode().to_bytes())
+            .push_slice(&ms.encode(NullCtx).to_bytes())
             .into_script();
         let witness = vec![] as Vec<Vec<u8>>;
         let (des, stack) = from_txin_with_witness_stack(&script_pubkey, &script_sig, &witness)
@@ -374,11 +380,16 @@ mod tests {
         //This test passes incorrect witness argument.
         let ms = ms_str!("and_v(vc:pk_k({}),c:pk_k({}))", pks[0], pks[1]);
         let script_pubkey =
-            bitcoin::Address::p2shwsh(&ms.encode(), bitcoin::Network::Bitcoin).script_pubkey();
+            bitcoin::Address::p2shwsh(&ms.encode(NullCtx), bitcoin::Network::Bitcoin)
+                .script_pubkey();
         let script_sig = script::Builder::new()
-            .push_slice(&ms.encode().to_v0_p2wsh().to_bytes())
+            .push_slice(&ms.encode(NullCtx).to_v0_p2wsh().to_bytes())
             .into_script();
-        let witness = vec![sigs[1].clone(), sigs[3].clone(), ms.encode().to_bytes()];
+        let witness = vec![
+            sigs[1].clone(),
+            sigs[3].clone(),
+            ms.encode(NullCtx).to_bytes(),
+        ];
         let (des, stack) = from_txin_with_witness_stack(&script_pubkey, &script_sig, &witness)
             .expect("Descriptor/Witness stack creation to succeed");
         assert_eq!(Descriptor::ShWsh(ms.clone()), des);