Use Key instead of MiniscriptKey

One of the main traits in this lib is `MiniscriptKey`, we can shorten
this to `Key` with no loss of meaning. This makes the whole codebase
more terse. Terse code, if clear, is easier to read because there is
less clutter. Also terseness assists the formatter and can reduce lines
of code.

This patch is the result of running

  `s/MiniscriptKey/Key/g` on all source files.

To preserve backwards compatibility and make the library more
ergonomical to use; add a 'trait alias' of `MiniscriptKey` -> `Key`.

Author: tcharding

CHANGELOG.md

@@ -3,7 +3,7 @@
 - Fixed miniscript type system bug. This is a security vulnerability and users are strongly encouraged to upgrade.
 See this (link)[https://github.com/rust-bitcoin/rust-miniscript/pull/349/commits/db97c39afa4053c2c3917f04392f6e24964b3972] for details.
 - Support for `tr` descriptors with miniscript leaves and multi_a fragment
-- Changes to MiniscriptKey and ToPublicKey traits for x-only keys support
+- Changes to Key and ToPublicKey traits for x-only keys support
 - Add `PsbtExt` trait for psbt operations
   - `Psbt::update_desc` adds information from a descriptor to a psbt. This figures
     out the type of the descriptor and adds corresponding redeem script/witness script
@@ -33,7 +33,7 @@ See this (link)[https://github.com/rust-bitcoin/rust-miniscript/pull/349/commits
 - Remove `PkCtx` from the API
 - Move descriptors into their own types, with an enum containing all of them
 - Move descriptor functionality into a trait
-- Remove `FromStr` bound from `MiniscriptKey`and `MiniscriptKey::Hash`
+- Remove `FromStr` bound from `Key`and `Key::Hash`
 - Various `DescriptorPublicKey` improvements
 - Allow hardened paths in `DescriptorPublicKey`, remove direct `ToPublicKey` implementation
 - Change `Option` to `Result` in all APIs

examples/sign_multisig.rs

@@ -90,7 +90,7 @@ fn main() {
     assert_eq!(my_descriptor.max_satisfaction_weight().unwrap(), 258);
 
     // Sometimes it is necessary to have additional information to get the bitcoin::PublicKey
-    // from the MiniscriptKey which can supplied by `to_pk_ctx` parameter. For example,
+    // from the Key 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.
 

examples/verify_tx.rs

@@ -125,7 +125,7 @@ fn main() {
     //    signatures are not treated as having participated in the script
     let secp = secp256k1::Secp256k1::new();
     // Sometimes it is necessary to have additional information to get the bitcoin::PublicKey
-    // from the MiniscriptKey which can supplied by `to_pk_ctx` parameter. For example,
+    // from the Key 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 interpreter = miniscript::Interpreter::from_txdata(

integration_test/src/test_cpp.rs

@@ -11,7 +11,7 @@ use bitcoin::{self, Amount, OutPoint, Transaction, TxIn, TxOut, Txid};
 use bitcoincore_rpc::{json, Client, RpcApi};
 use miniscript::miniscript::iter;
 use miniscript::psbt::PsbtExt;
-use miniscript::MiniscriptKey;
+use miniscript::Key;
 use miniscript::Segwitv0;
 use miniscript::{Descriptor, DescriptorTrait, Miniscript};
 use std::collections::BTreeMap;

integration_test/src/test_desc.rs

@@ -15,7 +15,7 @@ use bitcoincore_rpc::{json, Client, RpcApi};
 use miniscript::miniscript::iter;
 use miniscript::psbt::{PsbtInputExt, PsbtExt};
 use miniscript::{Descriptor, DescriptorTrait, Miniscript, ToPublicKey};
-use miniscript::{MiniscriptKey, ScriptContext};
+use miniscript::{Key, ScriptContext};
 use std::collections::BTreeMap;
 
 use crate::test_util::{self, TestData};

src/descriptor/bare.rs

@@ -27,8 +27,7 @@ use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    BareCtx, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
-    TranslatePk,
+    BareCtx, Error, ForEach, ForEachKey, Key, Miniscript, Satisfier, ToPublicKey, TranslatePk,
 };
 
 use super::{
@@ -39,12 +38,12 @@ use super::{
 /// Create a Bare Descriptor. That is descriptor that is
 /// not wrapped in sh or wsh. This covers the Pk descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Bare<Pk: MiniscriptKey> {
+pub struct Bare<Pk: Key> {
     /// underlying miniscript
     ms: Miniscript<Pk, BareCtx>,
 }
 
-impl<Pk: MiniscriptKey> Bare<Pk> {
+impl<Pk: Key> Bare<Pk> {
     /// Create a new raw descriptor
     pub fn new(ms: Miniscript<Pk, BareCtx>) -> Result<Self, Error> {
         // do the top-level checks
@@ -63,7 +62,7 @@ impl<Pk: MiniscriptKey> Bare<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
+impl<Pk: Key + ToPublicKey> Bare<Pk> {
     /// Obtain the corresponding script pubkey for this descriptor
     /// Non failing verion of [`DescriptorTrait::script_pubkey`] for this descriptor
     pub fn spk(&self) -> Script {
@@ -83,32 +82,32 @@ impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Bare<Pk> {
+impl<Pk: Key> fmt::Debug for Bare<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self.ms)
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Bare<Pk> {
+impl<Pk: Key> fmt::Display for Bare<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let desc = format!("{}", self.ms);
         let checksum = desc_checksum(&desc).map_err(|_| fmt::Error)?;
         write!(f, "{}#{}", &desc, &checksum)
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Bare<Pk> {
+impl<Pk: Key> Liftable<Pk> for Bare<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         self.ms.lift()
     }
 }
 
 impl<Pk> FromTree for Bare<Pk>
 where
-    Pk: MiniscriptKey + FromStr,
+    Pk: Key + FromStr,
     Pk::Hash: FromStr,
     <Pk as FromStr>::Err: ToString,
-    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+    <<Pk as Key>::Hash as FromStr>::Err: ToString,
 {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         let sub = Miniscript::<Pk, BareCtx>::from_tree(&top)?;
@@ -119,10 +118,10 @@ where
 
 impl<Pk> FromStr for Bare<Pk>
 where
-    Pk: MiniscriptKey + FromStr,
+    Pk: Key + FromStr,
     Pk::Hash: FromStr,
     <Pk as FromStr>::Err: ToString,
-    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+    <<Pk as Key>::Hash as FromStr>::Err: ToString,
 {
     type Err = Error;
 
@@ -133,7 +132,7 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Bare<Pk> {
+impl<Pk: Key> DescriptorTrait<Pk> for Bare<Pk> {
     fn sanity_check(&self) -> Result<(), Error> {
         self.ms.sanity_check()?;
         Ok(())
@@ -202,7 +201,7 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Bare<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Bare<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Bare<Pk> {
     fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool
     where
         Pk: 'a,
@@ -212,7 +211,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Bare<Pk> {
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Bare<P> {
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Bare<P> {
     type Output = Bare<Q>;
 
     fn translate_pk<Fpk, Fpkh, E>(
@@ -223,7 +222,7 @@ impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Bare<P> {
     where
         Fpk: FnMut(&P) -> Result<Q, E>,
         Fpkh: FnMut(&P::Hash) -> Result<Q::Hash, E>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         Ok(Bare::new(
             self.ms
@@ -235,12 +234,12 @@ impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Bare<P> {
 
 /// A bare PkH descriptor at top level
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Pkh<Pk: MiniscriptKey> {
+pub struct Pkh<Pk: Key> {
     /// underlying publickey
     pk: Pk,
 }
 
-impl<Pk: MiniscriptKey> Pkh<Pk> {
+impl<Pk: Key> Pkh<Pk> {
     /// Create a new Pkh descriptor
     pub fn new(pk: Pk) -> Self {
         // do the top-level checks
@@ -258,7 +257,7 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
+impl<Pk: Key + ToPublicKey> Pkh<Pk> {
     /// Obtain the corresponding script pubkey for this descriptor
     /// Non failing verion of [`DescriptorTrait::script_pubkey`] for this descriptor
     pub fn spk(&self) -> Script {
@@ -285,32 +284,32 @@ impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Pkh<Pk> {
+impl<Pk: Key> fmt::Debug for Pkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "pkh({:?})", self.pk)
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Pkh<Pk> {
+impl<Pk: Key> fmt::Display for Pkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let desc = format!("pkh({})", self.pk);
         let checksum = desc_checksum(&desc).map_err(|_| fmt::Error)?;
         write!(f, "{}#{}", &desc, &checksum)
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Pkh<Pk> {
+impl<Pk: Key> Liftable<Pk> for Pkh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         Ok(semantic::Policy::KeyHash(self.pk.to_pubkeyhash()))
     }
 }
 
 impl<Pk> FromTree for Pkh<Pk>
 where
-    Pk: MiniscriptKey + FromStr,
+    Pk: Key + FromStr,
     Pk::Hash: FromStr,
     <Pk as FromStr>::Err: ToString,
-    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+    <<Pk as Key>::Hash as FromStr>::Err: ToString,
 {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "pkh" && top.args.len() == 1 {
@@ -329,10 +328,10 @@ where
 
 impl<Pk> FromStr for Pkh<Pk>
 where
-    Pk: MiniscriptKey + FromStr,
+    Pk: Key + FromStr,
     Pk::Hash: FromStr,
     <Pk as FromStr>::Err: ToString,
-    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+    <<Pk as Key>::Hash as FromStr>::Err: ToString,
 {
     type Err = Error;
 
@@ -343,7 +342,7 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
+impl<Pk: Key> DescriptorTrait<Pk> for Pkh<Pk> {
     fn sanity_check(&self) -> Result<(), Error> {
         Ok(())
     }
@@ -414,7 +413,7 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Pkh<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Pkh<Pk> {
     fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, mut pred: F) -> bool
     where
         Pk: 'a,
@@ -424,7 +423,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Pkh<Pk> {
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Pkh<P> {
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Pkh<P> {
     type Output = Pkh<Q>;
 
     fn translate_pk<Fpk, Fpkh, E>(
@@ -435,7 +434,7 @@ impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Pkh<P> {
     where
         Fpk: FnMut(&P) -> Result<Q, E>,
         Fpkh: FnMut(&P::Hash) -> Result<Q::Hash, E>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         Ok(Pkh::new(translatefpk(&self.pk)?))
     }

src/descriptor/key.rs

@@ -10,7 +10,7 @@ use bitcoin::{
     XOnlyPublicKey, XpubIdentifier,
 };
 
-use crate::{MiniscriptKey, ToPublicKey};
+use crate::{Key, ToPublicKey};
 
 /// The descriptor pubkey, either a single pubkey or an xpub.
 #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]
@@ -684,7 +684,7 @@ impl<K: InnerXKey> DescriptorXKey<K> {
     }
 }
 
-impl MiniscriptKey for DescriptorPublicKey {
+impl Key for DescriptorPublicKey {
     // This allows us to be able to derive public keys even for PkH s
     type Hash = Self;