blanket_traits: remove crate:: in a bunch of places

apoelstra · apoelstra · commit 3c1c896ace71 · 2024-03-05T21:29:20.000Z
diff --git a/src/descriptor/bare.rs b/src/descriptor/bare.rs
@@ -22,8 +22,8 @@ use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    BareCtx, Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey, TranslateErr,
-    TranslatePk, Translator,
+    BareCtx, Error, ForEachKey, FromStrKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
+    TranslateErr, TranslatePk, Translator,
 };
 
 /// Create a Bare Descriptor. That is descriptor that is
@@ -166,15 +166,15 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Bare<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> { self.ms.lift() }
 }
 
-impl<Pk: crate::FromStrKey> FromTree for Bare<Pk> {
+impl<Pk: FromStrKey> FromTree for Bare<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         let sub = Miniscript::<Pk, BareCtx>::from_tree(top)?;
         BareCtx::top_level_checks(&sub)?;
         Bare::new(sub)
     }
 }
 
-impl<Pk: crate::FromStrKey> core::str::FromStr for Bare<Pk> {
+impl<Pk: FromStrKey> core::str::FromStr for Bare<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let desc_str = verify_checksum(s)?;
@@ -364,7 +364,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Pkh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> FromTree for Pkh<Pk> {
+impl<Pk: FromStrKey> FromTree for Pkh<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "pkh" && top.args.len() == 1 {
             Ok(Pkh::new(expression::terminal(&top.args[0], |pk| Pk::from_str(pk))?)?)
@@ -378,7 +378,7 @@ impl<Pk: crate::FromStrKey> FromTree for Pkh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> core::str::FromStr for Pkh<Pk> {
+impl<Pk: FromStrKey> core::str::FromStr for Pkh<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let desc_str = verify_checksum(s)?;
diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs
@@ -25,8 +25,8 @@ use crate::miniscript::{satisfy, Legacy, Miniscript, Segwitv0};
 use crate::plan::{AssetProvider, Plan};
 use crate::prelude::*;
 use crate::{
-    expression, hash256, BareCtx, Error, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey,
-    TranslateErr, TranslatePk, Translator,
+    expression, hash256, BareCtx, Error, ForEachKey, FromStrKey, MiniscriptKey, Satisfier,
+    ToPublicKey, TranslateErr, TranslatePk, Translator,
 };
 
 mod bare;
@@ -918,7 +918,7 @@ impl Descriptor<DefiniteDescriptorKey> {
     }
 }
 
-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Descriptor<Pk> {
+impl<Pk: FromStrKey> crate::expression::FromTree for Descriptor<Pk> {
     /// Parse an expression tree into a descriptor.
     fn from_tree(top: &expression::Tree) -> Result<Descriptor<Pk>, Error> {
         Ok(match (top.name, top.args.len() as u32) {
@@ -932,7 +932,7 @@ impl<Pk: crate::FromStrKey> crate::expression::FromTree for Descriptor<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> FromStr for Descriptor<Pk> {
+impl<Pk: FromStrKey> FromStr for Descriptor<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Descriptor<Pk>, Error> {
         // tr tree parsing has special code
diff --git a/src/descriptor/segwitv0.rs b/src/descriptor/segwitv0.rs
@@ -20,8 +20,8 @@ use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::varint_len;
 use crate::{
-    Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey, TranslateErr,
-    TranslatePk, Translator,
+    Error, ForEachKey, FromStrKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey,
+    TranslateErr, TranslatePk, Translator,
 };
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -231,7 +231,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Wsh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Wsh<Pk> {
+impl<Pk: FromStrKey> crate::expression::FromTree for Wsh<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "wsh" && top.args.len() == 1 {
             let top = &top.args[0];
@@ -269,7 +269,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Wsh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> core::str::FromStr for Wsh<Pk> {
+impl<Pk: FromStrKey> core::str::FromStr for Wsh<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let desc_str = verify_checksum(s)?;
@@ -473,7 +473,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Wpkh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Wpkh<Pk> {
+impl<Pk: FromStrKey> crate::expression::FromTree for Wpkh<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "wpkh" && top.args.len() == 1 {
             Ok(Wpkh::new(expression::terminal(&top.args[0], |pk| Pk::from_str(pk))?)?)
@@ -487,7 +487,7 @@ impl<Pk: crate::FromStrKey> crate::expression::FromTree for Wpkh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> core::str::FromStr for Wpkh<Pk> {
+impl<Pk: FromStrKey> core::str::FromStr for Wpkh<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let desc_str = verify_checksum(s)?;
diff --git a/src/descriptor/sh.rs b/src/descriptor/sh.rs
@@ -24,8 +24,8 @@ use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    push_opcode_size, Error, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    ToPublicKey, TranslateErr, TranslatePk, Translator,
+    push_opcode_size, Error, ForEachKey, FromStrKey, Legacy, Miniscript, MiniscriptKey, Satisfier,
+    Segwitv0, ToPublicKey, TranslateErr, TranslatePk, Translator,
 };
 
 /// A Legacy p2sh Descriptor
@@ -81,7 +81,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Sh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Sh<Pk> {
+impl<Pk: FromStrKey> crate::expression::FromTree for Sh<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "sh" && top.args.len() == 1 {
             let top = &top.args[0];
@@ -106,7 +106,7 @@ impl<Pk: crate::FromStrKey> crate::expression::FromTree for Sh<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> core::str::FromStr for Sh<Pk> {
+impl<Pk: FromStrKey> core::str::FromStr for Sh<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let desc_str = verify_checksum(s)?;
diff --git a/src/descriptor/tr.rs b/src/descriptor/tr.rs
@@ -23,8 +23,8 @@ use crate::policy::Liftable;
 use crate::prelude::*;
 use crate::util::{varint_len, witness_size};
 use crate::{
-    errstr, Error, ForEachKey, MiniscriptKey, Satisfier, ScriptContext, Tap, ToPublicKey,
-    TranslateErr, TranslatePk, Translator,
+    errstr, Error, ForEachKey, FromStrKey, MiniscriptKey, Satisfier, ScriptContext, Tap,
+    ToPublicKey, TranslateErr, TranslatePk, Translator,
 };
 
 /// A Taproot Tree representation.
@@ -467,7 +467,7 @@ where
 }
 
 #[rustfmt::skip]
-impl<Pk: crate::FromStrKey> Tr<Pk> {
+impl<Pk: FromStrKey> Tr<Pk> {
     // Helper function to parse taproot script path
     fn parse_tr_script_spend(tree: &expression::Tree,) -> Result<TapTree<Pk>, Error> {
         match tree {
@@ -488,7 +488,7 @@ impl<Pk: crate::FromStrKey> Tr<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Tr<Pk> {
+impl<Pk: FromStrKey> crate::expression::FromTree for Tr<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "tr" {
             match top.args.len() {
@@ -530,7 +530,7 @@ impl<Pk: crate::FromStrKey> crate::expression::FromTree for Tr<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> core::str::FromStr for Tr<Pk> {
+impl<Pk: FromStrKey> core::str::FromStr for Tr<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let desc_str = verify_checksum(s)?;
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
@@ -19,7 +19,8 @@ use crate::miniscript::{types, ScriptContext};
 use crate::prelude::*;
 use crate::util::MsKeyBuilder;
 use crate::{
-    errstr, expression, AbsLockTime, Error, Miniscript, MiniscriptKey, Terminal, ToPublicKey,
+    errstr, expression, AbsLockTime, Error, FromStrKey, Miniscript, MiniscriptKey, Terminal,
+    ToPublicKey,
 };
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
@@ -240,15 +241,13 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {
     }
 }
 
-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> crate::expression::FromTree
-    for Arc<Terminal<Pk, Ctx>>
-{
+impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Arc<Terminal<Pk, Ctx>> {
     fn from_tree(top: &expression::Tree) -> Result<Arc<Terminal<Pk, Ctx>>, Error> {
         Ok(Arc::new(expression::FromTree::from_tree(top)?))
     }
 }
 
-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Terminal<Pk, Ctx> {
+impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Terminal<Pk, Ctx> {
     fn from_tree(top: &expression::Tree) -> Result<Terminal<Pk, Ctx>, Error> {
         let (frag_name, frag_wrap) = super::split_expression_name(top.name)?;
         let unwrapped = match (frag_name, top.args.len()) {
diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs
@@ -45,7 +45,8 @@ use crate::miniscript::decode::Terminal;
 use crate::miniscript::types::extra_props::ExtData;
 use crate::miniscript::types::Type;
 use crate::{
-    expression, plan, Error, ForEachKey, MiniscriptKey, ToPublicKey, TranslatePk, Translator,
+    expression, plan, Error, ForEachKey, FromStrKey, MiniscriptKey, ToPublicKey, TranslatePk,
+    Translator,
 };
 #[cfg(test)]
 mod ms_tests;
@@ -617,7 +618,7 @@ where
     Ok(ms)
 }
 
-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+impl<Pk: FromStrKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// Attempt to parse an insane(scripts don't clear sanity checks)
     /// from string into a Miniscript representation.
     /// Use this to parse scripts with repeated pubkeys, timelock mixing, malleable
@@ -648,17 +649,13 @@ impl<Pk: crate::FromStrKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     }
 }
 
-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> crate::expression::FromTree
-    for Arc<Miniscript<Pk, Ctx>>
-{
+impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Arc<Miniscript<Pk, Ctx>> {
     fn from_tree(top: &expression::Tree) -> Result<Arc<Miniscript<Pk, Ctx>>, Error> {
         Ok(Arc::new(expression::FromTree::from_tree(top)?))
     }
 }
 
-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> crate::expression::FromTree
-    for Miniscript<Pk, Ctx>
-{
+impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Miniscript<Pk, Ctx> {
     /// Parse an expression tree into a Miniscript. As a general rule, this
     /// should not be called directly; rather go through the descriptor API.
     fn from_tree(top: &expression::Tree) -> Result<Miniscript<Pk, Ctx>, Error> {
@@ -667,7 +664,7 @@ impl<Pk: crate::FromStrKey, Ctx: ScriptContext> crate::expression::FromTree
     }
 }
 
-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> str::FromStr for Miniscript<Pk, Ctx> {
+impl<Pk: FromStrKey, Ctx: ScriptContext> str::FromStr for Miniscript<Pk, Ctx> {
     type Err = Error;
     /// Parse a Miniscript from string and perform sanity checks
     /// See [Miniscript::from_str_insane] to parse scripts from string that
diff --git a/src/policy/concrete.rs b/src/policy/concrete.rs
@@ -29,7 +29,7 @@ use crate::prelude::*;
 use crate::sync::Arc;
 #[cfg(all(doc, not(feature = "compiler")))]
 use crate::Descriptor;
-use crate::{errstr, AbsLockTime, Error, ForEachKey, MiniscriptKey, Translator};
+use crate::{errstr, AbsLockTime, Error, ForEachKey, FromStrKey, MiniscriptKey, Translator};
 
 /// Maximum TapLeafs allowed in a compiled TapTree
 #[cfg(feature = "compiler")]
@@ -930,7 +930,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> str::FromStr for Policy<Pk> {
+impl<Pk: FromStrKey> str::FromStr for Policy<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Policy<Pk>, Error> {
         expression::check_valid_chars(s)?;
@@ -945,7 +945,7 @@ impl<Pk: crate::FromStrKey> str::FromStr for Policy<Pk> {
 serde_string_impl_pk!(Policy, "a miniscript concrete policy");
 
 #[rustfmt::skip]
-impl<Pk: crate::FromStrKey> Policy<Pk> {
+impl<Pk: FromStrKey> Policy<Pk> {
     /// Helper function for `from_tree` to parse subexpressions with
     /// names of the form x@y
     fn from_tree_prob(top: &expression::Tree, allow_prob: bool,)
@@ -1050,7 +1050,7 @@ impl<Pk: crate::FromStrKey> Policy<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> expression::FromTree for Policy<Pk> {
+impl<Pk: FromStrKey> expression::FromTree for Policy<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Policy<Pk>, Error> {
         Policy::from_tree_prob(top, false).map(|(_, result)| result)
     }
diff --git a/src/policy/semantic.rs b/src/policy/semantic.rs
@@ -15,7 +15,9 @@ use super::ENTAILMENT_MAX_TERMINALS;
 use crate::iter::{Tree, TreeLike};
 use crate::prelude::*;
 use crate::sync::Arc;
-use crate::{errstr, expression, AbsLockTime, Error, ForEachKey, MiniscriptKey, Translator};
+use crate::{
+    errstr, expression, AbsLockTime, Error, ForEachKey, FromStrKey, MiniscriptKey, Translator,
+};
 
 /// Abstract policy which corresponds to the semantics of a miniscript and
 /// which allows complex forms of analysis, e.g. filtering and normalization.
@@ -308,7 +310,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
     }
 }
 
-impl<Pk: crate::FromStrKey> str::FromStr for Policy<Pk> {
+impl<Pk: FromStrKey> str::FromStr for Policy<Pk> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Policy<Pk>, Error> {
         expression::check_valid_chars(s)?;
@@ -320,7 +322,7 @@ impl<Pk: crate::FromStrKey> str::FromStr for Policy<Pk> {
 
 serde_string_impl_pk!(Policy, "a miniscript semantic policy");
 
-impl<Pk: crate::FromStrKey> expression::FromTree for Policy<Pk> {
+impl<Pk: FromStrKey> expression::FromTree for Policy<Pk> {
     fn from_tree(top: &expression::Tree) -> Result<Policy<Pk>, Error> {
         match (top.name, top.args.len()) {
             ("UNSATISFIABLE", 0) => Ok(Policy::Unsatisfiable),

Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,8 @@ use crate::policy::{semantic, Liftable};`
`22`	`22`	`use crate::prelude::*;`
`23`	`23`	`use crate::util::{varint_len, witness_to_scriptsig};`
`24`	`24`	`use crate::{`
`25`		`- BareCtx, Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey, TranslateErr,`
`26`		`- TranslatePk, Translator,`
	`25`	`+ BareCtx, Error, ForEachKey, FromStrKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey,`
	`26`	`+ TranslateErr, TranslatePk, Translator,`
`27`	`27`	`};`
`28`	`28`
`29`	`29`	`/// Create a Bare Descriptor. That is descriptor that is`
`@@ -166,15 +166,15 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Bare<Pk> {`
`166`	`166`	`fn lift(&self) -> Result<semantic::Policy<Pk>, Error> { self.ms.lift() }`
`167`	`167`	`}`
`168`	`168`
`169`		`-impl<Pk: crate::FromStrKey> FromTree for Bare<Pk> {`
	`169`	`+impl<Pk: FromStrKey> FromTree for Bare<Pk> {`
`170`	`170`	`fn from_tree(top: &expression::Tree) -> Result<Self, Error> {`
`171`	`171`	`let sub = Miniscript::<Pk, BareCtx>::from_tree(top)?;`
`172`	`172`	`BareCtx::top_level_checks(&sub)?;`
`173`	`173`	`Bare::new(sub)`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`177`		`-impl<Pk: crate::FromStrKey> core::str::FromStr for Bare<Pk> {`
	`177`	`+impl<Pk: FromStrKey> core::str::FromStr for Bare<Pk> {`
`178`	`178`	`type Err = Error;`
`179`	`179`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`180`	`180`	`let desc_str = verify_checksum(s)?;`
`@@ -364,7 +364,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Pkh<Pk> {`
`364`	`364`	`}`
`365`	`365`	`}`
`366`	`366`
`367`		`-impl<Pk: crate::FromStrKey> FromTree for Pkh<Pk> {`
	`367`	`+impl<Pk: FromStrKey> FromTree for Pkh<Pk> {`
`368`	`368`	`fn from_tree(top: &expression::Tree) -> Result<Self, Error> {`
`369`	`369`	`if top.name == "pkh" && top.args.len() == 1 {`
`370`	`370`	`Ok(Pkh::new(expression::terminal(&top.args[0], \|pk\| Pk::from_str(pk))?)?)`
`@@ -378,7 +378,7 @@ impl<Pk: crate::FromStrKey> FromTree for Pkh<Pk> {`
`378`	`378`	`}`
`379`	`379`	`}`
`380`	`380`
`381`		`-impl<Pk: crate::FromStrKey> core::str::FromStr for Pkh<Pk> {`
	`381`	`+impl<Pk: FromStrKey> core::str::FromStr for Pkh<Pk> {`
`382`	`382`	`type Err = Error;`
`383`	`383`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`384`	`384`	`let desc_str = verify_checksum(s)?;`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ use crate::miniscript::{satisfy, Legacy, Miniscript, Segwitv0};`
`25`	`25`	`use crate::plan::{AssetProvider, Plan};`
`26`	`26`	`use crate::prelude::*;`
`27`	`27`	`use crate::{`
`28`		`- expression, hash256, BareCtx, Error, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey,`
`29`		`- TranslateErr, TranslatePk, Translator,`
	`28`	`+ expression, hash256, BareCtx, Error, ForEachKey, FromStrKey, MiniscriptKey, Satisfier,`
	`29`	`+ ToPublicKey, TranslateErr, TranslatePk, Translator,`
`30`	`30`	`};`
`31`	`31`
`32`	`32`	`mod bare;`
`@@ -918,7 +918,7 @@ impl Descriptor<DefiniteDescriptorKey> {`
`918`	`918`	`}`
`919`	`919`	`}`
`920`	`920`
`921`		`-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Descriptor<Pk> {`
	`921`	`+impl<Pk: FromStrKey> crate::expression::FromTree for Descriptor<Pk> {`
`922`	`922`	`/// Parse an expression tree into a descriptor.`
`923`	`923`	`fn from_tree(top: &expression::Tree) -> Result<Descriptor<Pk>, Error> {`
`924`	`924`	`Ok(match (top.name, top.args.len() as u32) {`
`@@ -932,7 +932,7 @@ impl<Pk: crate::FromStrKey> crate::expression::FromTree for Descriptor<Pk> {`
`932`	`932`	`}`
`933`	`933`	`}`
`934`	`934`
`935`		`-impl<Pk: crate::FromStrKey> FromStr for Descriptor<Pk> {`
	`935`	`+impl<Pk: FromStrKey> FromStr for Descriptor<Pk> {`
`936`	`936`	`type Err = Error;`
`937`	`937`	`fn from_str(s: &str) -> Result<Descriptor<Pk>, Error> {`
`938`	`938`	`// tr tree parsing has special code`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ use crate::policy::{semantic, Liftable};`
`20`	`20`	`use crate::prelude::*;`
`21`	`21`	`use crate::util::varint_len;`
`22`	`22`	`use crate::{`
`23`		`- Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey, TranslateErr,`
`24`		`- TranslatePk, Translator,`
	`23`	`+ Error, ForEachKey, FromStrKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey,`
	`24`	`+ TranslateErr, TranslatePk, Translator,`
`25`	`25`	`};`
`26`	`26`	`/// A Segwitv0 wsh descriptor`
`27`	`27`	`#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]`
`@@ -231,7 +231,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Wsh<Pk> {`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`
`234`		`-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Wsh<Pk> {`
	`234`	`+impl<Pk: FromStrKey> crate::expression::FromTree for Wsh<Pk> {`
`235`	`235`	`fn from_tree(top: &expression::Tree) -> Result<Self, Error> {`
`236`	`236`	`if top.name == "wsh" && top.args.len() == 1 {`
`237`	`237`	`let top = &top.args[0];`
`@@ -269,7 +269,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Wsh<Pk> {`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`
`272`		`-impl<Pk: crate::FromStrKey> core::str::FromStr for Wsh<Pk> {`
	`272`	`+impl<Pk: FromStrKey> core::str::FromStr for Wsh<Pk> {`
`273`	`273`	`type Err = Error;`
`274`	`274`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`275`	`275`	`let desc_str = verify_checksum(s)?;`
`@@ -473,7 +473,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Wpkh<Pk> {`
`473`	`473`	`}`
`474`	`474`	`}`
`475`	`475`
`476`		`-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Wpkh<Pk> {`
	`476`	`+impl<Pk: FromStrKey> crate::expression::FromTree for Wpkh<Pk> {`
`477`	`477`	`fn from_tree(top: &expression::Tree) -> Result<Self, Error> {`
`478`	`478`	`if top.name == "wpkh" && top.args.len() == 1 {`
`479`	`479`	`Ok(Wpkh::new(expression::terminal(&top.args[0], \|pk\| Pk::from_str(pk))?)?)`
`@@ -487,7 +487,7 @@ impl<Pk: crate::FromStrKey> crate::expression::FromTree for Wpkh<Pk> {`
`487`	`487`	`}`
`488`	`488`	`}`
`489`	`489`
`490`		`-impl<Pk: crate::FromStrKey> core::str::FromStr for Wpkh<Pk> {`
	`490`	`+impl<Pk: FromStrKey> core::str::FromStr for Wpkh<Pk> {`
`491`	`491`	`type Err = Error;`
`492`	`492`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`493`	`493`	`let desc_str = verify_checksum(s)?;`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ use crate::policy::{semantic, Liftable};`
`24`	`24`	`use crate::prelude::*;`
`25`	`25`	`use crate::util::{varint_len, witness_to_scriptsig};`
`26`	`26`	`use crate::{`
`27`		`- push_opcode_size, Error, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,`
`28`		`- ToPublicKey, TranslateErr, TranslatePk, Translator,`
	`27`	`+ push_opcode_size, Error, ForEachKey, FromStrKey, Legacy, Miniscript, MiniscriptKey, Satisfier,`
	`28`	`+ Segwitv0, ToPublicKey, TranslateErr, TranslatePk, Translator,`
`29`	`29`	`};`
`30`	`30`
`31`	`31`	`/// A Legacy p2sh Descriptor`
`@@ -81,7 +81,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Sh<Pk> {`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`-impl<Pk: crate::FromStrKey> crate::expression::FromTree for Sh<Pk> {`
	`84`	`+impl<Pk: FromStrKey> crate::expression::FromTree for Sh<Pk> {`
`85`	`85`	`fn from_tree(top: &expression::Tree) -> Result<Self, Error> {`
`86`	`86`	`if top.name == "sh" && top.args.len() == 1 {`
`87`	`87`	`let top = &top.args[0];`
`@@ -106,7 +106,7 @@ impl<Pk: crate::FromStrKey> crate::expression::FromTree for Sh<Pk> {`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`109`		`-impl<Pk: crate::FromStrKey> core::str::FromStr for Sh<Pk> {`
	`109`	`+impl<Pk: FromStrKey> core::str::FromStr for Sh<Pk> {`
`110`	`110`	`type Err = Error;`
`111`	`111`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`112`	`112`	`let desc_str = verify_checksum(s)?;`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,8 @@ use crate::miniscript::{types, ScriptContext};`
`19`	`19`	`use crate::prelude::*;`
`20`	`20`	`use crate::util::MsKeyBuilder;`
`21`	`21`	`use crate::{`
`22`		`- errstr, expression, AbsLockTime, Error, Miniscript, MiniscriptKey, Terminal, ToPublicKey,`
	`22`	`+ errstr, expression, AbsLockTime, Error, FromStrKey, Miniscript, MiniscriptKey, Terminal,`
	`23`	`+ ToPublicKey,`
`23`	`24`	`};`
`24`	`25`
`25`	`26`	`impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {`
`@@ -240,15 +241,13 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {`
`240`	`241`	`}`
`241`	`242`	`}`
`242`	`243`
`243`		`-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> crate::expression::FromTree`
`244`		`- for Arc<Terminal<Pk, Ctx>>`
`245`		`-{`
	`244`	`+impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Arc<Terminal<Pk, Ctx>> {`
`246`	`245`	`fn from_tree(top: &expression::Tree) -> Result<Arc<Terminal<Pk, Ctx>>, Error> {`
`247`	`246`	`Ok(Arc::new(expression::FromTree::from_tree(top)?))`
`248`	`247`	`}`
`249`	`248`	`}`
`250`	`249`
`251`		`-impl<Pk: crate::FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Terminal<Pk, Ctx> {`
	`250`	`+impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Terminal<Pk, Ctx> {`
`252`	`251`	`fn from_tree(top: &expression::Tree) -> Result<Terminal<Pk, Ctx>, Error> {`
`253`	`252`	`let (frag_name, frag_wrap) = super::split_expression_name(top.name)?;`
`254`	`253`	`let unwrapped = match (frag_name, top.args.len()) {`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ use crate::prelude::*;`
`29`	`29`	`use crate::sync::Arc;`
`30`	`30`	`#[cfg(all(doc, not(feature = "compiler")))]`
`31`	`31`	`use crate::Descriptor;`
`32`		`-use crate::{errstr, AbsLockTime, Error, ForEachKey, MiniscriptKey, Translator};`
	`32`	`+use crate::{errstr, AbsLockTime, Error, ForEachKey, FromStrKey, MiniscriptKey, Translator};`
`33`	`33`
`34`	`34`	`/// Maximum TapLeafs allowed in a compiled TapTree`
`35`	`35`	`#[cfg(feature = "compiler")]`
`@@ -930,7 +930,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {`
`930`	`930`	`}`
`931`	`931`	`}`
`932`	`932`
`933`		`-impl<Pk: crate::FromStrKey> str::FromStr for Policy<Pk> {`
	`933`	`+impl<Pk: FromStrKey> str::FromStr for Policy<Pk> {`
`934`	`934`	`type Err = Error;`
`935`	`935`	`fn from_str(s: &str) -> Result<Policy<Pk>, Error> {`
`936`	`936`	`expression::check_valid_chars(s)?;`
`@@ -945,7 +945,7 @@ impl<Pk: crate::FromStrKey> str::FromStr for Policy<Pk> {`
`945`	`945`	`serde_string_impl_pk!(Policy, "a miniscript concrete policy");`
`946`	`946`
`947`	`947`	`#[rustfmt::skip]`
`948`		`-impl<Pk: crate::FromStrKey> Policy<Pk> {`
	`948`	`+impl<Pk: FromStrKey> Policy<Pk> {`
`949`	`949`	/// Helper function for `from_tree` to parse subexpressions with
`950`	`950`	`/// names of the form x@y`
`951`	`951`	`fn from_tree_prob(top: &expression::Tree, allow_prob: bool,)`
`@@ -1050,7 +1050,7 @@ impl<Pk: crate::FromStrKey> Policy<Pk> {`
`1050`	`1050`	`}`
`1051`	`1051`	`}`
`1052`	`1052`
`1053`		`-impl<Pk: crate::FromStrKey> expression::FromTree for Policy<Pk> {`
	`1053`	`+impl<Pk: FromStrKey> expression::FromTree for Policy<Pk> {`
`1054`	`1054`	`fn from_tree(top: &expression::Tree) -> Result<Policy<Pk>, Error> {`
`1055`	`1055`	`Policy::from_tree_prob(top, false).map(\|(_, result)\| result)`
`1056`	`1056`	`}`