remove PkCtx

Author: apoelstra

examples/htlc.rs

@@ -19,7 +19,6 @@ extern crate miniscript;
 
 use bitcoin::Network;
 use miniscript::policy::{Concrete, Liftable};
-use miniscript::NullCtx;
 use miniscript::{Descriptor, DescriptorTrait};
 use std::str::FromStr;
 
@@ -55,20 +54,17 @@ fn main() {
     );
 
     assert_eq!(
-        format!("{:x}", htlc_descriptor.script_pubkey(NullCtx)),
+        format!("{:x}", htlc_descriptor.script_pubkey()),
         "0020d853877af928a8d2a569c9c0ed14bd16f6a80ce9cccaf8a6150fd8f7f8867ae2"
     );
 
     assert_eq!(
-        format!("{:x}", htlc_descriptor.explicit_script(NullCtx)),
+        format!("{:x}", htlc_descriptor.explicit_script()),
         "21022222222222222222222222222222222222222222222222222222222222222222ac6476a91451814f108670aced2d77c1805ddd6634bc9d473188ad025c11b26782012088a82011111111111111111111111111111111111111111111111111111111111111118768"
     );
 
     assert_eq!(
-        format!(
-            "{}",
-            htlc_descriptor.address(NullCtx, Network::Bitcoin).unwrap()
-        ),
+        format!("{}", htlc_descriptor.address(Network::Bitcoin).unwrap()),
         "bc1qmpfcw7he9z5d9ftfe8qw699azmm2sr8fen903fs4plv007yx0t3qxfmqv5"
     );
 }

examples/parse.rs

@@ -17,7 +17,7 @@
 extern crate bitcoin;
 extern crate miniscript;
 
-use miniscript::{DescriptorTrait, NullCtx};
+use miniscript::DescriptorTrait;
 use std::str::FromStr;
 
 fn main() {
@@ -37,12 +37,12 @@ fn main() {
     // 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(NullCtx)),
+        format!("{:x}", my_descriptor.script_pubkey()),
         "0020daef16dd7c946a3e735a6e43310cb2ce33dfd14a04f76bf8241a16654cb2f0f9"
     );
 
     assert_eq!(
-        format!("{:x}", my_descriptor.explicit_script(NullCtx)),
+        format!("{:x}", my_descriptor.explicit_script()),
         "21020202020202020202020202020202020202020202020202020202020202020202ac"
     );
 }

examples/sign_multisig.rs

@@ -18,7 +18,7 @@ extern crate bitcoin;
 extern crate miniscript;
 
 use bitcoin::secp256k1; // secp256k1 re-exported from rust-bitcoin
-use miniscript::{DescriptorTrait, NullCtx};
+use miniscript::DescriptorTrait;
 use std::collections::HashMap;
 use std::str::FromStr;
 
@@ -95,12 +95,12 @@ fn main() {
 
     // Observe the script properties, just for fun
     assert_eq!(
-        format!("{:x}", my_descriptor.script_pubkey(NullCtx)),
+        format!("{:x}", my_descriptor.script_pubkey()),
         "00200ed49b334a12c37f3df8a2974ad91ff95029215a2b53f78155be737907f06163"
     );
 
     assert_eq!(
-        format!("{:x}", my_descriptor.explicit_script(NullCtx)),
+        format!("{:x}", my_descriptor.explicit_script()),
         "52\
          21020202020202020202020202020202020202020202020202020202020202020202\
          21020102030405060708010203040506070801020304050607080000000000000000\
@@ -114,31 +114,23 @@ 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, NullCtx)
-        .is_err());
+    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).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, NullCtx)
-        .is_err());
+    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).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, NullCtx)
-        .is_ok());
+    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).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, NullCtx)
-        .is_ok());
+    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_ok());
     assert_ne!(tx.input[0], original_txin);
     assert_eq!(tx.input[0].witness.len(), 4); // 0, sig, sig, witness script
 }

examples/xpub_descriptors.rs

@@ -18,7 +18,7 @@ extern crate miniscript;
 
 use miniscript::bitcoin::{self, secp256k1};
 use miniscript::descriptor::PkTranslate2;
-use miniscript::{Descriptor, DescriptorPublicKey, DescriptorTrait, NullCtx};
+use miniscript::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 
 use std::str::FromStr;
 fn main() {
@@ -31,15 +31,15 @@ fn main() {
         .unwrap()
         .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
         .unwrap()
-        .address(NullCtx, bitcoin::Network::Bitcoin).unwrap();
+        .address(bitcoin::Network::Bitcoin).unwrap();
 
     let addr_two = Descriptor::<DescriptorPublicKey>::from_str(
             "wsh(sortedmulti(1,xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH,xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB))",
         )
         .unwrap()
         .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
         .unwrap()
-        .address(NullCtx, bitcoin::Network::Bitcoin).unwrap();
+        .address(bitcoin::Network::Bitcoin).unwrap();
     let expected = bitcoin::Address::from_str(
         "bc1qpq2cfgz5lktxzr5zqv7nrzz46hsvq3492ump9pz8rzcl8wqtwqcspx5y6a",
     )
@@ -55,7 +55,7 @@ fn main() {
         .derive(5)
         .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
         .unwrap()
-        .address(NullCtx, bitcoin::Network::Bitcoin).unwrap();
+        .address(bitcoin::Network::Bitcoin).unwrap();
 
     let addr_two = Descriptor::<DescriptorPublicKey>::from_str(
             "sh(wsh(sortedmulti(1,xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH/0/0/*,xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB/1/0/*)))",
@@ -64,7 +64,7 @@ fn main() {
         .derive(5)
         .translate_pk2(|xpk| xpk.derive_public_key(&secp_ctx))
         .unwrap()
-        .address(NullCtx, bitcoin::Network::Bitcoin).unwrap();
+        .address(bitcoin::Network::Bitcoin).unwrap();
     let expected = bitcoin::Address::from_str("325zcVBN5o2eqqqtGwPjmtDd8dJRyYP82s").unwrap();
     assert_eq!(addr_one, expected);
     assert_eq!(addr_two, expected);

fuzz/fuzz_targets/roundtrip_miniscript_script.rs

@@ -2,15 +2,14 @@ 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(NullCtx);
+        let output = pt.encode();
         assert_eq!(pt.script_size(), output.len());
         assert_eq!(output, script);
     }

src/descriptor/bare.rs

@@ -111,49 +111,40 @@ where
         Ok(())
     }
 
-    fn address<ToPkCtx: Copy>(
-        &self,
-        _to_pk_ctx: ToPkCtx,
-        _network: bitcoin::Network,
-    ) -> Option<bitcoin::Address>
+    fn address(&self, _network: bitcoin::Network) -> Option<bitcoin::Address>
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
         None
     }
 
-    fn script_pubkey<ToPkCtx: Copy>(&self, to_pk_ctx: ToPkCtx) -> Script
+    fn script_pubkey(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
-        self.ms.encode(to_pk_ctx)
+        self.ms.encode()
     }
 
-    fn unsigned_script_sig<ToPkCtx: Copy>(&self, _to_pk_ctx: ToPkCtx) -> Script
+    fn unsigned_script_sig(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
         Script::new()
     }
 
-    fn explicit_script<ToPkCtx: Copy>(&self, to_pk_ctx: ToPkCtx) -> Script
+    fn explicit_script(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
-        self.ms.encode(to_pk_ctx)
+        self.ms.encode()
     }
 
-    fn get_satisfaction<ToPkCtx, S>(
-        &self,
-        satisfier: S,
-        to_pk_ctx: ToPkCtx,
-    ) -> Result<(Vec<Vec<u8>>, Script), Error>
+    fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
     where
-        ToPkCtx: Copy,
-        Pk: ToPublicKey<ToPkCtx>,
-        S: Satisfier<ToPkCtx, Pk>,
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
     {
-        let ms = self.ms.satisfy(satisfier, to_pk_ctx)?;
+        let ms = self.ms.satisfy(satisfier)?;
         let script_sig = witness_to_scriptsig(&ms);
         let witness = vec![];
         Ok((witness, script_sig))
@@ -164,11 +155,11 @@ where
         Some(4 * (varint_len(scriptsig_len) + scriptsig_len))
     }
 
-    fn script_code<ToPkCtx: Copy>(&self, to_pk_ctx: ToPkCtx) -> Script
+    fn script_code(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
-        self.script_pubkey(to_pk_ctx)
+        self.script_pubkey()
     }
 }
 
@@ -276,76 +267,63 @@ where
         Ok(())
     }
 
-    fn address<ToPkCtx: Copy>(
-        &self,
-        to_pk_ctx: ToPkCtx,
-        network: bitcoin::Network,
-    ) -> Option<bitcoin::Address>
+    fn address(&self, network: bitcoin::Network) -> Option<bitcoin::Address>
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
-        Some(bitcoin::Address::p2pkh(
-            &self.pk.to_public_key(to_pk_ctx),
-            network,
-        ))
+        Some(bitcoin::Address::p2pkh(&self.pk.to_public_key(), network))
     }
 
-    fn script_pubkey<ToPkCtx: Copy>(&self, to_pk_ctx: ToPkCtx) -> Script
+    fn script_pubkey(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
-        let addr =
-            bitcoin::Address::p2pkh(&self.pk.to_public_key(to_pk_ctx), bitcoin::Network::Bitcoin);
+        let addr = bitcoin::Address::p2pkh(&self.pk.to_public_key(), bitcoin::Network::Bitcoin);
         addr.script_pubkey()
     }
 
-    fn unsigned_script_sig<ToPkCtx: Copy>(&self, _to_pk_ctx: ToPkCtx) -> Script
+    fn unsigned_script_sig(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
         Script::new()
     }
 
-    fn explicit_script<ToPkCtx: Copy>(&self, to_pk_ctx: ToPkCtx) -> Script
+    fn explicit_script(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
-        self.script_pubkey(to_pk_ctx)
+        self.script_pubkey()
     }
 
-    fn get_satisfaction<ToPkCtx, S>(
-        &self,
-        satisfier: S,
-        to_pk_ctx: ToPkCtx,
-    ) -> Result<(Vec<Vec<u8>>, Script), Error>
+    fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
     where
-        ToPkCtx: Copy,
-        Pk: ToPublicKey<ToPkCtx>,
-        S: Satisfier<ToPkCtx, Pk>,
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
     {
-        if let Some(sig) = satisfier.lookup_sig(&self.pk, to_pk_ctx) {
+        if let Some(sig) = satisfier.lookup_sig(&self.pk) {
             let mut sig_vec = sig.0.serialize_der().to_vec();
             sig_vec.push(sig.1.as_u32() as u8);
             let script_sig = script::Builder::new()
                 .push_slice(&sig_vec[..])
-                .push_key(&self.pk.to_public_key(to_pk_ctx))
+                .push_key(&self.pk.to_public_key())
                 .into_script();
             let witness = vec![];
             Ok((witness, script_sig))
         } else {
-            Err(Error::MissingSig(self.pk.to_public_key(to_pk_ctx)))
+            Err(Error::MissingSig(self.pk.to_public_key()))
         }
     }
 
     fn max_satisfaction_weight(&self) -> Option<usize> {
         Some(4 * (1 + 73 + self.pk.serialized_len()))
     }
 
-    fn script_code<ToPkCtx: Copy>(&self, to_pk_ctx: ToPkCtx) -> Script
+    fn script_code(&self) -> Script
     where
-        Pk: ToPublicKey<ToPkCtx>,
+        Pk: ToPublicKey,
     {
-        self.script_pubkey(to_pk_ctx)
+        self.script_pubkey()
     }
 }
 

src/descriptor/key.rs

@@ -605,37 +605,6 @@ impl MiniscriptKey for DescriptorPublicKey {
     }
 }
 
-/// Context information for deriving a public key from DescriptorPublicKey
-#[derive(Debug)]
-pub struct DescriptorPublicKeyCtx<'secp, C: 'secp + secp256k1::Verification> {
-    /// The underlying secp context
-    secp_ctx: &'secp secp256k1::Secp256k1<C>,
-    /// The index in case the descriptor is ranged
-    /// If the DescriptorPublicKey is unranged this field is not used.
-    index: u32,
-}
-
-impl<'secp, C: secp256k1::Verification> Clone for DescriptorPublicKeyCtx<'secp, C> {
-    fn clone(&self) -> Self {
-        Self {
-            secp_ctx: &self.secp_ctx,
-            index: self.index,
-        }
-    }
-}
-
-impl<'secp, C: secp256k1::Verification> Copy for DescriptorPublicKeyCtx<'secp, C> {}
-
-impl<'secp, C: secp256k1::Verification> DescriptorPublicKeyCtx<'secp, C> {
-    /// Create a new context
-    pub fn new(secp_ctx: &'secp secp256k1::Secp256k1<C>, index: u32) -> Self {
-        Self {
-            secp_ctx: secp_ctx,
-            index: index,
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::{DescriptorKeyParseError, DescriptorPublicKey, DescriptorSecretKey};