descriptor: rename PkTranslate to TranslatePk; re-export at the root

Author: apoelstra

examples/xpub_descriptors.rs

@@ -17,8 +17,7 @@
 extern crate miniscript;
 
 use miniscript::bitcoin::{self, secp256k1};
-use miniscript::descriptor::PkTranslate2;
-use miniscript::{Descriptor, DescriptorPublicKey, DescriptorTrait};
+use miniscript::{Descriptor, DescriptorPublicKey, DescriptorTrait, TranslatePk2};
 
 use std::str::FromStr;
 fn main() {

src/descriptor/bare.rs

@@ -30,7 +30,7 @@ use {BareCtx, Error, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, PkTranslate,
+    DescriptorTrait, TranslatePk,
 };
 
 /// Create a Bare Descriptor. That is descriptor that is
@@ -163,7 +163,7 @@ where
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Bare<P> {
+impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Bare<P> {
     type Output = Bare<Q>;
 
     fn translate_pk<Fpk, Fpkh, E>(
@@ -327,7 +327,7 @@ where
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Pkh<P> {
+impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Pkh<P> {
     type Output = Pkh<Q>;
 
     fn translate_pk<Fpk, Fpkh, E>(

src/descriptor/mod.rs

@@ -157,7 +157,7 @@ pub trait DescriptorTrait<Pk: MiniscriptKey> {
 /// This will panic if translatefpk returns an uncompressed key when
 /// converting to a Segwit descriptor. To prevent this panic, ensure
 /// translatefpk returns an error in this case instead.
-pub trait PkTranslate<P: MiniscriptKey, Q: MiniscriptKey> {
+pub trait TranslatePk<P: MiniscriptKey, Q: MiniscriptKey> {
     /// The associated output type. This must be Self<Q>
     type Output;
 
@@ -188,17 +188,17 @@ pub trait PkTranslate<P: MiniscriptKey, Q: MiniscriptKey> {
     }
 }
 
-/// Variant of `PkTranslate` where P and Q both have the same hash
+/// Variant of `TranslatePk` where P and Q both have the same hash
 /// type, and the hashes can be converted by just cloning them
-pub trait PkTranslate1<P: MiniscriptKey, Q: MiniscriptKey<Hash = P::Hash>>:
-    PkTranslate<P, Q>
+pub trait TranslatePk1<P: MiniscriptKey, Q: MiniscriptKey<Hash = P::Hash>>:
+    TranslatePk<P, Q>
 {
     /// Translate a struct from one generic to another where the
     /// translation for Pk is provided by translatefpk
     fn translate_pk1<Fpk, E>(
         &self,
         translatefpk: Fpk,
-    ) -> Result<<Self as PkTranslate<P, Q>>::Output, E>
+    ) -> Result<<Self as TranslatePk<P, Q>>::Output, E>
     where
         Fpk: FnMut(&P) -> Result<Q, E>,
     {
@@ -210,24 +210,24 @@ pub trait PkTranslate1<P: MiniscriptKey, Q: MiniscriptKey<Hash = P::Hash>>:
     fn translate_pk1_infallible<Fpk: FnMut(&P) -> Q>(
         &self,
         translatefpk: Fpk,
-    ) -> <Self as PkTranslate<P, Q>>::Output {
+    ) -> <Self as TranslatePk<P, Q>>::Output {
         self.translate_pk_infallible(translatefpk, P::Hash::clone)
     }
 }
-impl<P: MiniscriptKey, Q: MiniscriptKey<Hash = P::Hash>, T: PkTranslate<P, Q>> PkTranslate1<P, Q>
+impl<P: MiniscriptKey, Q: MiniscriptKey<Hash = P::Hash>, T: TranslatePk<P, Q>> TranslatePk1<P, Q>
     for T
 {
 }
 
-/// Variant of `PkTranslate` where P's hash is P, so the hashes
+/// Variant of `TranslatePk` where P's hash is P, so the hashes
 /// can be converted by reusing the key-conversion function
-pub trait PkTranslate2<P: MiniscriptKey<Hash = P>, Q: MiniscriptKey>: PkTranslate<P, Q> {
+pub trait TranslatePk2<P: MiniscriptKey<Hash = P>, Q: MiniscriptKey>: TranslatePk<P, Q> {
     /// Translate a struct from one generic to another where the
     /// translation for Pk is provided by translatefpk
     fn translate_pk2<Fpk: Fn(&P) -> Result<Q, E>, E>(
         &self,
         translatefpk: Fpk,
-    ) -> Result<<Self as PkTranslate<P, Q>>::Output, E> {
+    ) -> Result<<Self as TranslatePk<P, Q>>::Output, E> {
         self.translate_pk(&translatefpk, |h| {
             translatefpk(h).map(|q| q.to_pubkeyhash())
         })
@@ -238,23 +238,23 @@ pub trait PkTranslate2<P: MiniscriptKey<Hash = P>, Q: MiniscriptKey>: PkTranslat
     fn translate_pk2_infallible<Fpk: Fn(&P) -> Q>(
         &self,
         translatefpk: Fpk,
-    ) -> <Self as PkTranslate<P, Q>>::Output {
+    ) -> <Self as TranslatePk<P, Q>>::Output {
         self.translate_pk_infallible(&translatefpk, |h| translatefpk(h).to_pubkeyhash())
     }
 }
-impl<P: MiniscriptKey<Hash = P>, Q: MiniscriptKey, T: PkTranslate<P, Q>> PkTranslate2<P, Q> for T {}
+impl<P: MiniscriptKey<Hash = P>, Q: MiniscriptKey, T: TranslatePk<P, Q>> TranslatePk2<P, Q> for T {}
 
-/// Variant of `PkTranslate` where Q's hash is `hash160` so we can
+/// Variant of `TranslatePk` where Q's hash is `hash160` so we can
 /// derive hashes by calling `hash_to_hash160`
-pub trait PkTranslate3<P: MiniscriptKey + ToPublicKey, Q: MiniscriptKey<Hash = hash160::Hash>>:
-    PkTranslate<P, Q>
+pub trait TranslatePk3<P: MiniscriptKey + ToPublicKey, Q: MiniscriptKey<Hash = hash160::Hash>>:
+    TranslatePk<P, Q>
 {
     /// Translate a struct from one generic to another where the
     /// translation for Pk is provided by translatefpk
     fn translate_pk3<Fpk, E>(
         &self,
         translatefpk: Fpk,
-    ) -> Result<<Self as PkTranslate<P, Q>>::Output, E>
+    ) -> Result<<Self as TranslatePk<P, Q>>::Output, E>
     where
         Fpk: FnMut(&P) -> Result<Q, E>,
     {
@@ -266,19 +266,19 @@ pub trait PkTranslate3<P: MiniscriptKey + ToPublicKey, Q: MiniscriptKey<Hash = h
     fn translate_pk3_infallible<Fpk: FnMut(&P) -> Q>(
         &self,
         translatefpk: Fpk,
-    ) -> <Self as PkTranslate<P, Q>>::Output {
+    ) -> <Self as TranslatePk<P, Q>>::Output {
         self.translate_pk_infallible(translatefpk, P::hash_to_hash160)
     }
 }
 impl<
         P: MiniscriptKey + ToPublicKey,
         Q: MiniscriptKey<Hash = hash160::Hash>,
-        T: PkTranslate<P, Q>,
-    > PkTranslate3<P, Q> for T
+        T: TranslatePk<P, Q>,
+    > TranslatePk3<P, Q> for T
 {
 }
 
-// There are some additional convenience functions we could add to  `PkTranslate`
+// There are some additional convenience functions we could add to  `TranslatePk`
 // for the common special cases where `P::Hash == Q::Hash`, or when `P == P::Hash`,
 // but these are blocked on https://github.com/rust-lang/rust/issues/20041 which
 // is unlikely to arrive in Rust very soon, as of Jan 2021. Should revisit this.
@@ -383,7 +383,7 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Descriptor<P> {
+impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Descriptor<P> {
     type Output = Descriptor<Q>;
     /// Convert a descriptor using abstract keys to one using specific keys
     /// This will panic if translatefpk returns an uncompressed key when
@@ -683,7 +683,7 @@ serde_string_impl_pk!(Descriptor, "a script descriptor");
 #[cfg(test)]
 mod tests {
     use super::checksum::desc_checksum;
-    use super::{DescriptorTrait, PkTranslate2};
+    use super::{DescriptorTrait, TranslatePk2};
     use bitcoin::blockdata::opcodes::all::{OP_CLTV, OP_CSV};
     use bitcoin::blockdata::script::Instruction;
     use bitcoin::blockdata::{opcodes, script};

src/descriptor/segwitv0.rs

@@ -28,7 +28,7 @@ use {Error, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey};
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, PkTranslate, SortedMultiVec,
+    DescriptorTrait, SortedMultiVec, TranslatePk,
 };
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
@@ -232,7 +232,7 @@ where
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Wsh<P> {
+impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Wsh<P> {
     type Output = Wsh<Q>;
 
     fn translate_pk<Fpk, Fpkh, E>(
@@ -411,7 +411,7 @@ where
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Wpkh<P> {
+impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Wpkh<P> {
     type Output = Wpkh<Q>;
 
     fn translate_pk<Fpk, Fpkh, E>(

src/descriptor/sh.rs

@@ -31,7 +31,7 @@ use {Error, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey}
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, PkTranslate, SortedMultiVec, Wpkh, Wsh,
+    DescriptorTrait, SortedMultiVec, TranslatePk, Wpkh, Wsh,
 };
 
 /// A Legacy p2sh Descriptor
@@ -322,7 +322,7 @@ where
     }
 }
 
-impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Sh<P> {
+impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Sh<P> {
     type Output = Sh<Q>;
 
     fn translate_pk<Fpk, Fpkh, E>(

src/lib.rs

@@ -129,6 +129,7 @@ use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, sha256, Hash};
 
 pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
+pub use descriptor::{TranslatePk, TranslatePk1, TranslatePk2, TranslatePk3};
 pub use interpreter::Interpreter;
 pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0};
 pub use miniscript::decode::Terminal;

src/miniscript/astelem.rs

@@ -19,25 +19,20 @@
 //! encoding in Bitcoin script, as well as a datatype. Full details
 //! are given on the Miniscript website.
 
+use std::str::FromStr;
+use std::sync::Arc;
 use std::{fmt, str};
 
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
 
-use descriptor::PkTranslate;
 use errstr;
 use expression;
 use miniscript::types::{self, Property};
 use miniscript::ScriptContext;
 use script_num_size;
-use std::sync::Arc;
-use str::FromStr;
-use Error;
-use Miniscript;
-use MiniscriptKey;
-use Terminal;
-use ToPublicKey;
+use {Error, Miniscript, MiniscriptKey, Terminal, ToPublicKey, TranslatePk};
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
     /// Internal helper function for displaying wrapper types; returns
@@ -60,7 +55,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Q: MiniscriptKey, Ctx: ScriptContext> PkTranslate<Pk, Q>
+impl<Pk: MiniscriptKey, Q: MiniscriptKey, Ctx: ScriptContext> TranslatePk<Pk, Q>
     for Terminal<Pk, Ctx>
 {
     type Output = Terminal<Q, Ctx>;

src/miniscript/mod.rs

@@ -44,7 +44,6 @@ pub mod types;
 
 use self::lex::{lex, TokenIter};
 use self::types::Property;
-use descriptor::PkTranslate;
 pub use miniscript::context::ScriptContext;
 use miniscript::decode::Terminal;
 use miniscript::types::extra_props::ExtData;
@@ -53,7 +52,7 @@ use miniscript::types::Type;
 use std::cmp;
 use std::sync::Arc;
 use MiniscriptKey;
-use {expression, Error, ToPublicKey};
+use {expression, Error, ToPublicKey, TranslatePk};
 
 /// Top-level script AST type
 #[derive(Clone, Hash)]
@@ -231,7 +230,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Q: MiniscriptKey, Ctx: ScriptContext> PkTranslate<Pk, Q>
+impl<Pk: MiniscriptKey, Q: MiniscriptKey, Ctx: ScriptContext> TranslatePk<Pk, Q>
     for Miniscript<Pk, Ctx>
 {
     type Output = Miniscript<Q, Ctx>;
@@ -400,21 +399,18 @@ serde_string_impl_pk!(Miniscript, "a miniscript", Ctx; ScriptContext);
 mod tests {
     use super::Segwitv0;
     use super::{Miniscript, ScriptContext};
-    use descriptor::{PkTranslate, PkTranslate1};
     use hex_script;
     use miniscript::types::{self, ExtData, Property, Type};
     use miniscript::Terminal;
     use policy::Liftable;
     use std::marker::PhantomData;
-    use DummyKey;
-    use DummyKeyHash;
+    use {DummyKey, DummyKeyHash, MiniscriptKey, TranslatePk, TranslatePk1};
 
     use bitcoin::hashes::{hash160, sha256, Hash};
     use bitcoin::{self, secp256k1};
     use std::str;
     use std::str::FromStr;
     use std::sync::Arc;
-    use MiniscriptKey;
 
     type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;