Replace misc uses of Pk: FromStr bound with impl_block_str!

The benefits of these will be obivious in the subsequent overhaul
commits

Author: sanket1729

src/descriptor/tr.rs

@@ -388,36 +388,31 @@ where
     }
 }
 
-impl_from_tree!(
+impl_block_str!(
     Tr<Pk>,
-    fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
-        // Helper function to parse taproot script path
-        fn parse_tr_script_spend<Pk: MiniscriptKey>(
-            tree: &expression::Tree,
-        ) -> Result<TapTree<Pk>, Error>
-        where
-            Pk: MiniscriptKey + FromStr,
-            Pk::Hash: FromStr,
-            <Pk as FromStr>::Err: ToString,
-            <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
-        {
-            match tree {
-                expression::Tree { name, args } if !name.is_empty() && args.is_empty() => {
-                    let script = Miniscript::<Pk, Tap>::from_str(name)?;
-                    Ok(TapTree::Leaf(Arc::new(script)))
-                }
-                expression::Tree { name, args } if name.is_empty() && args.len() == 2 => {
-                    let left = parse_tr_script_spend(&args[0])?;
-                    let right = parse_tr_script_spend(&args[1])?;
-                    Ok(TapTree::Tree(Arc::new(left), Arc::new(right)))
-                }
-                _ => Err(Error::Unexpected(
-                    "unknown format for script spending paths while parsing taproot descriptor"
-                        .to_string(),
-                )),
+    // Helper function to parse taproot script path
+    fn parse_tr_script_spend(tree: &expression::Tree) -> Result<TapTree<Pk>, Error> {
+        match tree {
+            expression::Tree { name, args } if !name.is_empty() && args.is_empty() => {
+                let script = Miniscript::<Pk, Tap>::from_str(name)?;
+                Ok(TapTree::Leaf(Arc::new(script)))
+            }
+            expression::Tree { name, args } if name.is_empty() && args.len() == 2 => {
+                let left = Self::parse_tr_script_spend(&args[0])?;
+                let right = Self::parse_tr_script_spend(&args[1])?;
+                Ok(TapTree::Tree(Arc::new(left), Arc::new(right)))
             }
+            _ => Err(Error::Unexpected(
+                "unknown format for script spending paths while parsing taproot descriptor"
+                    .to_string(),
+            )),
         }
+    }
+);
 
+impl_from_tree!(
+    Tr<Pk>,
+    fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "tr" {
             match top.args.len() {
                 1 => {
@@ -443,7 +438,7 @@ impl_from_tree!(
                         )));
                     }
                     let tree = &top.args[1];
-                    let ret = parse_tr_script_spend(tree)?;
+                    let ret = Self::parse_tr_script_spend(tree)?;
                     Ok(Tr {
                         internal_key: expression::terminal(key, Pk::from_str)?,
                         tree: Some(ret),

src/macros.rs

@@ -50,6 +50,23 @@ macro_rules! impl_from_str {
     };
 }
 
+/// Macro for implementing FromTree trait. This avoids copying all the Pk::Associated type bounds
+/// throughout the codebase.
+macro_rules! impl_block_str {
+    ($(;$gen:ident; $gen_con:ident, )* $name: ty $(, $it: item)*) => {
+        impl<Pk $(, $gen)*> $name
+        where
+            Pk: MiniscriptKey + std::str::FromStr,
+            Pk::Hash : std::str::FromStr,
+            <Pk as std::str::FromStr>::Err: std::string::ToString,
+            <<Pk as MiniscriptKey>::Hash as std::str::FromStr>::Err: std::string::ToString,
+            $($gen : $gen_con,)*
+            {
+                $($it)*
+            }
+    };
+}
+
 /// A macro that implements serde serialization and deserialization using the
 /// `fmt::Display` and `str::FromStr` traits.
 macro_rules! serde_string_impl_pk {

src/miniscript/mod.rs

@@ -338,7 +338,11 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
         };
         Ok(ms)
     }
+}
 
+impl_block_str!(
+    ;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
@@ -347,11 +351,6 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// insane scripts. In general, in a multi-party setting users should only
     /// accept sane scripts.
     pub fn from_str_insane(s: &str) -> Result<Miniscript<Pk, Ctx>, Error>
-    where
-        Pk: str::FromStr,
-        Pk::Hash: str::FromStr,
-        <Pk as str::FromStr>::Err: ToString,
-        <<Pk as MiniscriptKey>::Hash as str::FromStr>::Err: ToString,
     {
         // This checks for invalid ASCII chars
         let top = expression::Tree::from_str(s)?;
@@ -363,7 +362,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
             Ok(ms)
         }
     }
-}
+);
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// Attempt to produce non-malleable satisfying witness for the
@@ -475,8 +474,7 @@ mod tests {
     use crate::policy::Liftable;
     use crate::prelude::*;
     use crate::{
-        hex_script, DummyKey, DummyKeyHash, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
-        TranslatePk1, TranslatePk2,
+        hex_script, DummyKey, DummyKeyHash, Satisfier, ToPublicKey, TranslatePk, TranslatePk2,
     };
 
     type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;
@@ -503,19 +501,11 @@ mod tests {
         ret
     }
 
-    fn string_rtt<Pk, Ctx, Str1, Str2>(
-        script: Miniscript<Pk, Ctx>,
-        expected_debug: Str1,
-        expected_display: Str2,
-    ) where
-        Pk: MiniscriptKey + str::FromStr,
-        Pk::Hash: str::FromStr,
-        Ctx: ScriptContext,
-        <Pk as str::FromStr>::Err: ToString,
-        <<Pk as MiniscriptKey>::Hash as str::FromStr>::Err: ToString,
-        Str1: Into<Option<&'static str>>,
-        Str2: Into<Option<&'static str>>,
-    {
+    fn string_rtt<Ctx: ScriptContext>(
+        script: Miniscript<bitcoin::PublicKey, Ctx>,
+        expected_debug: &str,
+        expected_display: &str,
+    ) {
         assert_eq!(script.ty.corr.base, types::Base::B);
         let debug = format!("{:?}", script);
         let display = format!("{}", script);
@@ -527,12 +517,24 @@ mod tests {
         }
         let roundtrip = Miniscript::from_str(&display).expect("parse string serialization");
         assert_eq!(roundtrip, script);
+    }
 
-        let translated = script.translate_pk_infallible(Pk::clone, Pk::Hash::clone);
-        assert_eq!(translated, script);
-
-        let translated = script.translate_pk1_infallible(Pk::clone);
-        assert_eq!(translated, script);
+    fn dummy_string_rtt<Ctx: ScriptContext>(
+        script: Miniscript<DummyKey, Ctx>,
+        expected_debug: &str,
+        expected_display: &str,
+    ) {
+        assert_eq!(script.ty.corr.base, types::Base::B);
+        let debug = format!("{:?}", script);
+        let display = format!("{}", script);
+        if let Some(expected) = expected_debug.into() {
+            assert_eq!(debug, expected);
+        }
+        if let Some(expected) = expected_display.into() {
+            assert_eq!(display, expected);
+        }
+        let roundtrip = Miniscript::from_str(&display).expect("parse string serialization");
+        assert_eq!(roundtrip, script);
     }
 
     fn script_rtt<Str1: Into<Option<&'static str>>>(script: Segwitv0Script, expected_hex: Str1) {
@@ -648,7 +650,7 @@ mod tests {
             ext: ExtData::cast_check(ExtData::from_pk_k::<Segwitv0>()).unwrap(),
             phantom: PhantomData,
         };
-        string_rtt(pkk_ms, "[B/onduesm]c:[K/onduesm]pk_k(DummyKey)", "pk()");
+        dummy_string_rtt(pkk_ms, "[B/onduesm]c:[K/onduesm]pk_k(DummyKey)", "pk()");
 
         let pkh_ms: Miniscript<DummyKey, Segwitv0> = Miniscript {
             node: Terminal::Check(Arc::new(Miniscript {
@@ -661,7 +663,7 @@ mod tests {
             ext: ExtData::cast_check(ExtData::from_pk_h::<Segwitv0>()).unwrap(),
             phantom: PhantomData,
         };
-        string_rtt(pkh_ms, "[B/nduesm]c:[K/nduesm]pk_h(DummyKeyHash)", "pkh()");
+        dummy_string_rtt(pkh_ms, "[B/nduesm]c:[K/nduesm]pk_h(DummyKeyHash)", "pkh()");
 
         let pkk_ms: Segwitv0Script = Miniscript {
             node: Terminal::Check(Arc::new(Miniscript {

src/policy/concrete.rs

@@ -698,13 +698,8 @@ impl_from_str!(
 
 serde_string_impl_pk!(Policy, "a miniscript concrete policy");
 
-impl<Pk> Policy<Pk>
-where
-    Pk: MiniscriptKey + str::FromStr,
-    Pk::Hash: str::FromStr,
-    <Pk as str::FromStr>::Err: ToString,
-    <<Pk as MiniscriptKey>::Hash as str::FromStr>::Err: ToString,
-{
+impl_block_str!(
+    Policy<Pk>,
     /// Helper function for `from_tree` to parse subexpressions with
     /// names of the form x@y
     fn from_tree_prob(
@@ -808,7 +803,7 @@ where
         }
         .map(|res| (frag_prob, res))
     }
-}
+);
 
 impl_from_tree!(
     Policy<Pk>,