Fix type inference for the tr() descriptor, add basic tests

Author: afilini

src/descriptor/dsl.rs

@@ -77,24 +77,34 @@ macro_rules! impl_top_level_pk {
 #[macro_export]
 macro_rules! impl_top_level_tr {
     ( $internal_key:expr, $tap_tree:expr ) => {{
-        use $crate::miniscript::descriptor::{Descriptor, DescriptorPublicKey, Tr};
+        use $crate::miniscript::descriptor::{
+            Descriptor, DescriptorPublicKey, KeyMap, TapTree, Tr,
+        };
         use $crate::miniscript::Tap;
 
         #[allow(unused_imports)]
-        use $crate::keys::{DescriptorKey, IntoDescriptorKey};
+        use $crate::keys::{DescriptorKey, IntoDescriptorKey, ValidNetworks};
+
         let secp = $crate::bitcoin::secp256k1::Secp256k1::new();
 
         $internal_key
             .into_descriptor_key()
             .and_then(|key: DescriptorKey<Tap>| key.extract(&secp))
             .map_err($crate::descriptor::DescriptorError::Key)
             .and_then(|(pk, mut key_map, mut valid_networks)| {
-                let tap_tree = $tap_tree.map(|(tap_tree, tree_keymap, tree_networks)| {
-                    key_map.extend(tree_keymap.into_iter());
-                    valid_networks = $crate::keys::merge_networks(&valid_networks, &tree_networks);
-
-                    tap_tree
-                });
+                let tap_tree = $tap_tree.map(
+                    |(tap_tree, tree_keymap, tree_networks): (
+                        TapTree<DescriptorPublicKey>,
+                        KeyMap,
+                        ValidNetworks,
+                    )| {
+                        key_map.extend(tree_keymap.into_iter());
+                        valid_networks =
+                            $crate::keys::merge_networks(&valid_networks, &tree_networks);
+
+                        tap_tree
+                    },
+                );
 
                 Ok((
                     Descriptor::<DescriptorPublicKey>::Tr(Tr::new(pk, tap_tree)?),
@@ -1179,4 +1189,35 @@ mod test {
 
         descriptor!(wsh(v: pk(uncompressed_pk))).unwrap();
     }
+
+    #[test]
+    fn test_dsl_tr_only_key() {
+        let private_key =
+            PrivateKey::from_wif("cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR").unwrap();
+        let (descriptor, _, _) = descriptor!(tr(private_key)).unwrap();
+
+        assert_eq!(
+            descriptor.to_string(),
+            "tr(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)#heq9m95v"
+        )
+    }
+
+    #[test]
+    fn test_dsl_tr_simple_tree() {
+        let private_key =
+            PrivateKey::from_wif("cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR").unwrap();
+        let (descriptor, _, _) =
+            descriptor!(tr(private_key, { pk(private_key), pk(private_key) })).unwrap();
+
+        assert_eq!(descriptor.to_string(), "tr(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c,{pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c),pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)})#xy5fjw6d")
+    }
+
+    #[test]
+    fn test_dsl_tr_single_leaf() {
+        let private_key =
+            PrivateKey::from_wif("cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR").unwrap();
+        let (descriptor, _, _) = descriptor!(tr(private_key, pk(private_key))).unwrap();
+
+        assert_eq!(descriptor.to_string(), "tr(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c,pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c))#lzl2vmc7")
+    }
 }

src/wallet/signer.rs

@@ -302,13 +302,12 @@ impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
         let tap_key_origins = psbt.inputs[input_index]
             .tap_key_origins
             .iter()
-            .map(|(pk, (_, keysource))| (SinglePubKey::XOnly(*pk), keysource))
-            .collect::<Vec<_>>();
+            .map(|(pk, (_, keysource))| (SinglePubKey::XOnly(*pk), keysource));
         let (public_key, full_path) = match psbt.inputs[input_index]
             .bip32_derivation
             .iter()
             .map(|(pk, keysource)| (SinglePubKey::FullKey(PublicKey::new(*pk)), keysource))
-            .chain(tap_key_origins.into_iter())
+            .chain(tap_key_origins)
             .filter_map(|(pk, keysource)| {
                 if self.matches(keysource, secp).is_some() {
                     Some((pk, keysource.1.clone()))