Fix clippy warning 'wrong_self_convention'

diff --git a/src/descriptor/dsl.rs b/src/descriptor/dsl.rs
index bc1f72567d8ed1e8ff7291053be8eb8a336b690a..75d2d1473bf6edc9ebdc97bbb46b65e2de71ab2f 100644 (file)
--- a/src/descriptor/dsl.rs
+++ b/src/descriptor/dsl.rs
@@ -79,7 +79,7 @@ macro_rules! impl_top_level_pk {
         use $crate::keys::{DescriptorKey, ToDescriptorKey};
         let secp = $crate::bitcoin::secp256k1::Secp256k1::new();
 
-        $key.to_descriptor_key()
+        $key.into_descriptor_key()
             .and_then(|key: DescriptorKey<$ctx>| key.extract(&secp))
             .map_err($crate::descriptor::DescriptorError::Key)
             .map(|(pk, key_map, valid_networks)| ($inner_type::new(pk), key_map, valid_networks))
@@ -230,7 +230,7 @@ macro_rules! impl_sortedmulti {
 
         let mut keys = vec![];
         $(
-            keys.push($key.to_descriptor_key());
+            keys.push($key.into_descriptor_key());
         )*
 
         keys.into_iter().collect::<Result<Vec<_>, _>>()
@@ -658,7 +658,7 @@ macro_rules! fragment {
 
         let mut keys = vec![];
         $(
-            keys.push($key.to_descriptor_key());
+            keys.push($key.into_descriptor_key());
         )*
 
         keys.into_iter().collect::<Result<Vec<_>, _>>()
@@ -808,7 +808,7 @@ mod test {
         let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
 
         let path = bip32::DerivationPath::from_str("m/0").unwrap();
-        let desc_key = (xprv, path.clone()).to_descriptor_key().unwrap();
+        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
         check(
             descriptor!(pk(desc_key)),
             false,
@@ -820,7 +820,7 @@ mod test {
             ],
         );
 
-        let desc_key = (xprv, path.clone()).to_descriptor_key().unwrap();
+        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
         check(
             descriptor!(pkh(desc_key)),
             false,
@@ -833,8 +833,8 @@ mod test {
         );
 
         let path2 = bip32::DerivationPath::from_str("m/2147483647'/0").unwrap();
-        let desc_key1 = (xprv, path).to_descriptor_key().unwrap();
-        let desc_key2 = (xprv, path2).to_descriptor_key().unwrap();
+        let desc_key1 = (xprv, path).into_descriptor_key().unwrap();
+        let desc_key2 = (xprv, path2).into_descriptor_key().unwrap();
 
         check(
             descriptor!(sh(multi(1, desc_key1, desc_key2))),
@@ -853,7 +853,7 @@ mod test {
         let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
 
         let path = bip32::DerivationPath::from_str("m/0").unwrap();
-        let desc_key = (xprv, path.clone()).to_descriptor_key().unwrap();
+        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
         check(
             descriptor!(wpkh(desc_key)),
             true,
@@ -865,7 +865,7 @@ mod test {
             ],
         );
 
-        let desc_key = (xprv, path.clone()).to_descriptor_key().unwrap();
+        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
         check(
             descriptor!(sh(wpkh(desc_key))),
             true,
@@ -878,8 +878,8 @@ mod test {
         );
 
         let path2 = bip32::DerivationPath::from_str("m/2147483647'/0").unwrap();
-        let desc_key1 = (xprv, path.clone()).to_descriptor_key().unwrap();
-        let desc_key2 = (xprv, path2.clone()).to_descriptor_key().unwrap();
+        let desc_key1 = (xprv, path.clone()).into_descriptor_key().unwrap();
+        let desc_key2 = (xprv, path2.clone()).into_descriptor_key().unwrap();
         check(
             descriptor!(wsh(multi(1, desc_key1, desc_key2))),
             true,
@@ -891,8 +891,8 @@ mod test {
             ],
         );
 
-        let desc_key1 = (xprv, path).to_descriptor_key().unwrap();
-        let desc_key2 = (xprv, path2).to_descriptor_key().unwrap();
+        let desc_key1 = (xprv, path).into_descriptor_key().unwrap();
+        let desc_key2 = (xprv, path2).into_descriptor_key().unwrap();
         check(
             descriptor!(sh(wsh(multi(1, desc_key1, desc_key2)))),
             true,
@@ -968,7 +968,7 @@ mod test {
     fn test_valid_networks() {
         let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
         let path = bip32::DerivationPath::from_str("m/0").unwrap();
-        let desc_key = (xprv, path.clone()).to_descriptor_key().unwrap();
+        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
 
         let (_desc, _key_map, valid_networks) = descriptor!(pkh(desc_key)).unwrap();
         assert_eq!(
@@ -978,7 +978,7 @@ mod test {
 
         let xprv = bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").unwrap();
         let path = bip32::DerivationPath::from_str("m/10/20/30/40").unwrap();
-        let desc_key = (xprv, path.clone()).to_descriptor_key().unwrap();
+        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
 
         let (_desc, _key_map, valid_networks) = descriptor!(wpkh(desc_key)).unwrap();
         assert_eq!(valid_networks, [Bitcoin].iter().cloned().collect());
@@ -991,26 +991,26 @@ mod test {
 
         let xprv1 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
         let path1 = bip32::DerivationPath::from_str("m/0").unwrap();
-        let desc_key1 = (xprv1, path1.clone()).to_descriptor_key().unwrap();
+        let desc_key1 = (xprv1, path1.clone()).into_descriptor_key().unwrap();
 
         let xprv2 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPegBHHnq7YEgM815dG24M2Jk5RVqipgDxF1HJ1tsnT815X5Fd5FRfMVUs8NZs9XCb6y9an8hRPThnhfwfXJ36intaekySHGF").unwrap();
         let path2 = bip32::DerivationPath::from_str("m/2147483647'/0").unwrap();
-        let desc_key2 = (xprv2, path2.clone()).to_descriptor_key().unwrap();
+        let desc_key2 = (xprv2, path2.clone()).into_descriptor_key().unwrap();
 
         let xprv3 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPdZXrcHNLf5JAJWFAoJ2TrstMRdSKtEggz6PddbuSkvHKM9oKJyFgZV1B7rw8oChspxyYbtmEXYyg1AjfWbL3ho3XHDpHRZf").unwrap();
         let path3 = bip32::DerivationPath::from_str("m/10/20/30/40").unwrap();
-        let desc_key3 = (xprv3, path3.clone()).to_descriptor_key().unwrap();
+        let desc_key3 = (xprv3, path3.clone()).into_descriptor_key().unwrap();
 
         let (_desc, key_map, _valid_networks) =
             descriptor!(sh(wsh(multi(2, desc_key1, desc_key2, desc_key3)))).unwrap();
         assert_eq!(key_map.len(), 3);
 
         let desc_key1: DescriptorKey<Segwitv0> =
-            (xprv1, path1.clone()).to_descriptor_key().unwrap();
+            (xprv1, path1.clone()).into_descriptor_key().unwrap();
         let desc_key2: DescriptorKey<Segwitv0> =
-            (xprv2, path2.clone()).to_descriptor_key().unwrap();
+            (xprv2, path2.clone()).into_descriptor_key().unwrap();
         let desc_key3: DescriptorKey<Segwitv0> =
-            (xprv3, path3.clone()).to_descriptor_key().unwrap();
+            (xprv3, path3.clone()).into_descriptor_key().unwrap();
 
         let (key1, _key_map, _valid_networks) = desc_key1.extract(&secp).unwrap();
         let (key2, _key_map, _valid_networks) = desc_key2.extract(&secp).unwrap();
@@ -1026,13 +1026,13 @@ mod test {
         // this compiles
         let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
         let path = bip32::DerivationPath::from_str("m/0").unwrap();
-        let desc_key: DescriptorKey<Legacy> = (xprv, path.clone()).to_descriptor_key().unwrap();
+        let desc_key: DescriptorKey<Legacy> = (xprv, path.clone()).into_descriptor_key().unwrap();
 
         let (desc, _key_map, _valid_networks) = descriptor!(pkh(desc_key)).unwrap();
         assert_eq!(desc.to_string(), "pkh(tpubD6NzVbkrYhZ4WR7a4vY1VT3khMJMeAxVsfq9TBJyJWrNk247zCJtV7AWf6UJP7rAVsn8NNKdJi3gFyKPTmWZS9iukb91xbn2HbFSMQm2igY/0/*)#yrnz9pp2");
 
         // as expected this does not compile due to invalid context
-        //let desc_key:DescriptorKey<Segwitv0> = (xprv, path.clone()).to_descriptor_key().unwrap();
+        //let desc_key:DescriptorKey<Segwitv0> = (xprv, path.clone()).into_descriptor_key().unwrap();
         //let (desc, _key_map, _valid_networks) = descriptor!(pkh(desc_key)).unwrap();
     }
 

diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs
index 1932202992b6fbe740305b64cf9cf1aec7ce1bc2..4b9aec469b9d564cdf89c21fb185121d6cd5d365 100644 (file)
--- a/src/descriptor/mod.rs
+++ b/src/descriptor/mod.rs
@@ -74,7 +74,7 @@ pub type HDKeyPaths = BTreeMap<PublicKey, KeySource>;
 /// Trait for types which can be converted into an [`ExtendedDescriptor`] and a [`KeyMap`] usable by a wallet in a specific [`Network`]
 pub trait ToWalletDescriptor {
     /// Convert to wallet descriptor
-    fn to_wallet_descriptor(
+    fn into_wallet_descriptor(
         self,
         secp: &SecpCtx,
         network: Network,
@@ -82,7 +82,7 @@ pub trait ToWalletDescriptor {
 }
 
 impl ToWalletDescriptor for &str {
-    fn to_wallet_descriptor(
+    fn into_wallet_descriptor(
         self,
         secp: &SecpCtx,
         network: Network,
@@ -102,32 +102,33 @@ impl ToWalletDescriptor for &str {
             self
         };
 
-        ExtendedDescriptor::parse_descriptor(secp, descriptor)?.to_wallet_descriptor(secp, network)
+        ExtendedDescriptor::parse_descriptor(secp, descriptor)?
+            .into_wallet_descriptor(secp, network)
     }
 }
 
 impl ToWalletDescriptor for &String {
-    fn to_wallet_descriptor(
+    fn into_wallet_descriptor(
         self,
         secp: &SecpCtx,
         network: Network,
     ) -> Result<(ExtendedDescriptor, KeyMap), DescriptorError> {
-        self.as_str().to_wallet_descriptor(secp, network)
+        self.as_str().into_wallet_descriptor(secp, network)
     }
 }
 
 impl ToWalletDescriptor for ExtendedDescriptor {
-    fn to_wallet_descriptor(
+    fn into_wallet_descriptor(
         self,
         secp: &SecpCtx,
         network: Network,
     ) -> Result<(ExtendedDescriptor, KeyMap), DescriptorError> {
-        (self, KeyMap::default()).to_wallet_descriptor(secp, network)
+        (self, KeyMap::default()).into_wallet_descriptor(secp, network)
     }
 }
 
 impl ToWalletDescriptor for (ExtendedDescriptor, KeyMap) {
-    fn to_wallet_descriptor(
+    fn into_wallet_descriptor(
         self,
         secp: &SecpCtx,
         network: Network,
@@ -137,11 +138,11 @@ impl ToWalletDescriptor for (ExtendedDescriptor, KeyMap) {
         let check_key = |pk: &DescriptorPublicKey| {
             let (pk, _, networks) = if self.0.is_witness() {
                 let desciptor_key: DescriptorKey<miniscript::Segwitv0> =
-                    pk.clone().to_descriptor_key()?;
+                    pk.clone().into_descriptor_key()?;
                 desciptor_key.extract(&secp)?
             } else {
                 let desciptor_key: DescriptorKey<miniscript::Legacy> =
-                    pk.clone().to_descriptor_key()?;
+                    pk.clone().into_descriptor_key()?;
                 desciptor_key.extract(&secp)?
             };
 
@@ -160,7 +161,7 @@ impl ToWalletDescriptor for (ExtendedDescriptor, KeyMap) {
 }
 
 impl ToWalletDescriptor for DescriptorTemplateOut {
-    fn to_wallet_descriptor(
+    fn into_wallet_descriptor(
         self,
         _secp: &SecpCtx,
         network: Network,
@@ -622,14 +623,16 @@ mod test {
 
         // here `to_descriptor_key` will set the valid networks for the key to only mainnet, since
         // we are using an "xpub"
-        let key = (xpub, path).to_descriptor_key().unwrap();
+        let key = (xpub, path).into_descriptor_key().unwrap();
         // override it with any. this happens in some key conversions, like bip39
         let key = key.override_valid_networks(any_network());
 
         // make a descriptor out of it
         let desc = crate::descriptor!(wpkh(key)).unwrap();
         // this should conver the key that supports "any_network" to the right network (testnet)
-        let (wallet_desc, _) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, _) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
 
         assert_eq!(wallet_desc.to_string(), "wpkh(tpubDEnoLuPdBep9bzw5LoGYpsxUQYheRQ9gcgrJhJEcdKFB9cWQRyYmkCyRoTqeD4tJYiVVgt6A3rN6rWn9RYhR9sBsGxji29LYWHuKKbdb1ev/0/*)#y8p7e8kk");
     }
@@ -640,30 +643,30 @@ mod test {
         let secp = Secp256k1::new();
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#tqz0nc62"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/2/*)#67ju93jw"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#67ju93jw"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(matches!(
             desc.err(),
             Some(DescriptorError::InvalidDescriptorChecksum)
         ));
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#67ju93jw"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(matches!(
             desc.err(),
             Some(DescriptorError::InvalidDescriptorChecksum)
@@ -676,38 +679,38 @@ mod test {
         let secp = Secp256k1::new();
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Regtest);
+            .into_wallet_descriptor(&secp, Network::Regtest);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Regtest);
+            .into_wallet_descriptor(&secp, Network::Regtest);
         assert!(desc.is_ok());
 
         let desc = "sh(wpkh(02864bb4ad00cefa806098a69e192bbda937494e69eb452b87bb3f20f6283baedb))"
-            .to_wallet_descriptor(&secp, Network::Testnet);
+            .into_wallet_descriptor(&secp, Network::Testnet);
         assert!(desc.is_ok());
 
         let desc = "sh(wpkh(02864bb4ad00cefa806098a69e192bbda937494e69eb452b87bb3f20f6283baedb))"
-            .to_wallet_descriptor(&secp, Network::Bitcoin);
+            .into_wallet_descriptor(&secp, Network::Bitcoin);
         assert!(desc.is_ok());
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Bitcoin);
+            .into_wallet_descriptor(&secp, Network::Bitcoin);
         assert!(matches!(
             desc.err(),
             Some(DescriptorError::Key(KeyError::InvalidNetwork))
         ));
 
         let desc = "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/2/*)"
-            .to_wallet_descriptor(&secp, Network::Bitcoin);
+            .into_wallet_descriptor(&secp, Network::Bitcoin);
         assert!(matches!(
             desc.err(),
             Some(DescriptorError::Key(KeyError::InvalidNetwork))
@@ -721,17 +724,19 @@ mod test {
 
         let tpub = bip32::ExtendedPubKey::from_str("tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK").unwrap();
         let path = bip32::DerivationPath::from_str("m/1/2").unwrap();
-        let key = (tpub, path).to_descriptor_key().unwrap();
+        let key = (tpub, path).into_descriptor_key().unwrap();
 
         // make a descriptor out of it
         let desc = crate::descriptor!(wpkh(key)).unwrap();
 
-        let (wallet_desc, _) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, _) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let wallet_desc_str = wallet_desc.to_string();
         assert_eq!(wallet_desc_str, "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/2/*)#67ju93jw");
 
         let (wallet_desc2, _) = wallet_desc_str
-            .to_wallet_descriptor(&secp, Network::Testnet)
+            .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
         assert_eq!(wallet_desc, wallet_desc2)
     }

diff --git a/src/descriptor/policy.rs b/src/descriptor/policy.rs
index 83c6731ec9e7c6ec9bd1e9ba9bf4a150a4ce1883..11f8ed861f8902e32d97f219a8b53917d758ac7c 100644 (file)
--- a/src/descriptor/policy.rs
+++ b/src/descriptor/policy.rs
@@ -913,8 +913,8 @@ mod test {
         let tprv = bip32::ExtendedPrivKey::from_str(tprv).unwrap();
         let tpub = bip32::ExtendedPubKey::from_private(&secp, &tprv);
         let fingerprint = tprv.fingerprint(&secp);
-        let prvkey = (tprv, path.clone()).to_descriptor_key().unwrap();
-        let pubkey = (tpub, path).to_descriptor_key().unwrap();
+        let prvkey = (tprv, path.clone()).into_descriptor_key().unwrap();
+        let pubkey = (tpub, path).into_descriptor_key().unwrap();
 
         (prvkey, pubkey, fingerprint)
     }
@@ -927,7 +927,9 @@ mod test {
 
         let (prvkey, pubkey, fingerprint) = setup_keys(TPRV0_STR);
         let desc = descriptor!(wpkh(pubkey)).unwrap();
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, &Secp256k1::new())
@@ -940,7 +942,9 @@ mod test {
         assert!(matches!(&policy.contribution, Satisfaction::None));
 
         let desc = descriptor!(wpkh(prvkey)).unwrap();
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, &Secp256k1::new())
@@ -1023,7 +1027,9 @@ mod test {
         let (_prvkey0, pubkey0, fingerprint0) = setup_keys(TPRV0_STR);
         let (prvkey1, _pubkey1, fingerprint1) = setup_keys(TPRV1_STR);
         let desc = descriptor!(sh(multi(1, pubkey0, prvkey1))).unwrap();
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, &Secp256k1::new())
@@ -1053,7 +1059,9 @@ mod test {
         let (prvkey0, _pubkey0, fingerprint0) = setup_keys(TPRV0_STR);
         let (prvkey1, _pubkey1, fingerprint1) = setup_keys(TPRV1_STR);
         let desc = descriptor!(sh(multi(2, prvkey0, prvkey1))).unwrap();
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, &Secp256k1::new())
@@ -1083,7 +1091,9 @@ mod test {
 
         let (prvkey, pubkey, fingerprint) = setup_keys(TPRV0_STR);
         let desc = descriptor!(wpkh(pubkey)).unwrap();
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let single_key = wallet_desc.derive(0);
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = single_key
@@ -1097,7 +1107,9 @@ mod test {
         assert!(matches!(&policy.contribution, Satisfaction::None));
 
         let desc = descriptor!(wpkh(prvkey)).unwrap();
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let single_key = wallet_desc.derive(0);
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = single_key
@@ -1122,7 +1134,9 @@ mod test {
         let (_prvkey0, pubkey0, fingerprint0) = setup_keys(TPRV0_STR);
         let (prvkey1, _pubkey1, fingerprint1) = setup_keys(TPRV1_STR);
         let desc = descriptor!(sh(multi(1, pubkey0, prvkey1))).unwrap();
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let single_key = wallet_desc.derive(0);
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = single_key
@@ -1164,7 +1178,9 @@ mod test {
         )))
         .unwrap();
 
-        let (wallet_desc, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (wallet_desc, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
         let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, &Secp256k1::new())

diff --git a/src/descriptor/template.rs b/src/descriptor/template.rs
index f269c7a9767273e2a9c8e3e846d78df2f98dc7a0..95d0292155c6ab1478f9e1f8bca475aebdb10118 100644 (file)
--- a/src/descriptor/template.rs
+++ b/src/descriptor/template.rs
@@ -70,12 +70,12 @@ pub trait DescriptorTemplate {
 /// Turns a [`DescriptorTemplate`] into a valid wallet descriptor by calling its
 /// [`build`](DescriptorTemplate::build) method
 impl<T: DescriptorTemplate> ToWalletDescriptor for T {
-    fn to_wallet_descriptor(
+    fn into_wallet_descriptor(
         self,
         secp: &SecpCtx,
         network: Network,
     ) -> Result<(ExtendedDescriptor, KeyMap), DescriptorError> {
-        Ok(self.build()?.to_wallet_descriptor(secp, network)?)
+        Ok(self.build()?.into_wallet_descriptor(secp, network)?)
     }
 }
 

diff --git a/src/keys/mod.rs b/src/keys/mod.rs
index 065c008b0f8a5b0bfb092d8566432090f937e903..3f6bfe0395ea64ad6169462e4c6c3ca09560df63 100644 (file)
--- a/src/keys/mod.rs
+++ b/src/keys/mod.rs
@@ -212,8 +212,8 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 /// }
 ///
 /// impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for MyKeyType {
-///     fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
-///         self.pubkey.to_descriptor_key()
+///     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+///         self.pubkey.into_descriptor_key()
 ///     }
 /// }
 /// ```
@@ -233,7 +233,7 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 /// }
 ///
 /// impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for MyKeyType {
-///     fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+///     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
 ///         Ok(DescriptorKey::from_public(
 ///             DescriptorPublicKey::SinglePub(DescriptorSinglePub {
 ///                 origin: None,
@@ -258,9 +258,9 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 /// }
 ///
 /// impl<Ctx: ScriptContext + 'static> ToDescriptorKey<Ctx> for MyKeyType {
-///     fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+///     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
 ///         if Ctx::is_legacy() == self.is_legacy {
-///             self.pubkey.to_descriptor_key()
+///             self.pubkey.into_descriptor_key()
 ///         } else {
 ///             Err(KeyError::InvalidScriptContext)
 ///         }
@@ -286,8 +286,8 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 /// }
 ///
 /// impl ToDescriptorKey<bdk::miniscript::Segwitv0> for MySegwitOnlyKeyType {
-///     fn to_descriptor_key(self) -> Result<DescriptorKey<bdk::miniscript::Segwitv0>, KeyError> {
-///         self.pubkey.to_descriptor_key()
+///     fn into_descriptor_key(self) -> Result<DescriptorKey<bdk::miniscript::Segwitv0>, KeyError> {
+///         self.pubkey.into_descriptor_key()
 ///     }
 /// }
 ///
@@ -301,7 +301,7 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 /// ```
 pub trait ToDescriptorKey<Ctx: ScriptContext>: Sized {
     /// Turn the key into a [`DescriptorKey`] within the requested [`ScriptContext`]
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError>;
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError>;
 }
 
 /// Enum for extended keys that can be either `xprv` or `xpub`
@@ -499,14 +499,14 @@ let xprv = xkey.into_xprv(Network::Bitcoin).unwrap();
                 derivation_path,
                 wildcard: Wildcard::Unhardened,
             })
-            .to_descriptor_key(),
+            .into_descriptor_key(),
             ExtendedKey::Public((xpub, _)) => DescriptorPublicKey::XPub(DescriptorXKey {
                 origin,
                 xkey: xpub,
                 derivation_path,
                 wildcard: Wildcard::Unhardened,
             })
-            .to_descriptor_key(),
+            .into_descriptor_key(),
         }
     }
 }
@@ -588,8 +588,8 @@ where
     Ctx: ScriptContext,
     K: ToDescriptorKey<Ctx>,
 {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
-        let desc_key = self.key.to_descriptor_key()?;
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+        let desc_key = self.key.into_descriptor_key()?;
         Ok(desc_key.override_valid_networks(self.valid_networks))
     }
 }
@@ -712,7 +712,7 @@ impl<Ctx: ScriptContext> GeneratableKey<Ctx> for PrivateKey {
 }
 
 impl<Ctx: ScriptContext, T: DerivableKey<Ctx>> ToDescriptorKey<Ctx> for (T, bip32::DerivationPath) {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         self.0.into_descriptor_key(None, self.1)
     }
 }
@@ -720,7 +720,7 @@ impl<Ctx: ScriptContext, T: DerivableKey<Ctx>> ToDescriptorKey<Ctx> for (T, bip3
 impl<Ctx: ScriptContext, T: DerivableKey<Ctx>> ToDescriptorKey<Ctx>
     for (T, bip32::KeySource, bip32::DerivationPath)
 {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         self.0.into_descriptor_key(Some(self.1), self.2)
     }
 }
@@ -731,7 +731,7 @@ fn expand_multi_keys<Pk: ToDescriptorKey<Ctx>, Ctx: ScriptContext>(
 ) -> Result<(Vec<DescriptorPublicKey>, KeyMap, ValidNetworks), KeyError> {
     let (pks, key_maps_networks): (Vec<_>, Vec<_>) = pks
         .into_iter()
-        .map(|key| Ok::<_, KeyError>(key.to_descriptor_key()?.extract(secp)?))
+        .map(|key| Ok::<_, KeyError>(key.into_descriptor_key()?.extract(secp)?))
         .collect::<Result<Vec<_>, _>>()?
         .into_iter()
         .map(|(a, b, c)| (a, (b, c)))
@@ -756,7 +756,7 @@ pub fn make_pk<Pk: ToDescriptorKey<Ctx>, Ctx: ScriptContext>(
     descriptor_key: Pk,
     secp: &SecpCtx,
 ) -> Result<(Miniscript<DescriptorPublicKey, Ctx>, KeyMap, ValidNetworks), DescriptorError> {
-    let (key, key_map, valid_networks) = descriptor_key.to_descriptor_key()?.extract(secp)?;
+    let (key, key_map, valid_networks) = descriptor_key.into_descriptor_key()?.extract(secp)?;
     let minisc = Miniscript::from_ast(Terminal::PkK(key))?;
 
     minisc.check_minsicript()?;
@@ -803,13 +803,13 @@ where
 
 /// The "identity" conversion is used internally by some `bdk::fragment`s
 impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for DescriptorKey<Ctx> {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         Ok(self)
     }
 }
 
 impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for DescriptorPublicKey {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         let networks = match self {
             DescriptorPublicKey::SinglePub(_) => any_network(),
             DescriptorPublicKey::XPub(DescriptorXKey { xkey, .. })
@@ -825,17 +825,17 @@ impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for DescriptorPublicKey {
 }
 
 impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for PublicKey {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         DescriptorPublicKey::SinglePub(DescriptorSinglePub {
             key: self,
             origin: None,
         })
-        .to_descriptor_key()
+        .into_descriptor_key()
     }
 }
 
 impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for DescriptorSecretKey {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         let networks = match &self {
             DescriptorSecretKey::SinglePriv(sk) if sk.key.network == Network::Bitcoin => {
                 mainnet_network()
@@ -853,20 +853,20 @@ impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for DescriptorSecretKey {
 }
 
 impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for &'_ str {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         DescriptorSecretKey::from_str(self)
             .map_err(|e| KeyError::Message(e.to_string()))?
-            .to_descriptor_key()
+            .into_descriptor_key()
     }
 }
 
 impl<Ctx: ScriptContext> ToDescriptorKey<Ctx> for PrivateKey {
-    fn to_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
+    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         DescriptorSecretKey::SinglePriv(DescriptorSinglePriv {
             key: self,
             origin: None,
         })
-        .to_descriptor_key()
+        .into_descriptor_key()
     }
 }
 

diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs
index 69e578bf59207c18bcc7a456d2b8a328a1d38853..f862b6e2c657aacfda27ee7319c7532dd83ce769 100644 (file)
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -134,7 +134,7 @@ where
     ) -> Result<Self, Error> {
         let secp = Secp256k1::new();
 
-        let (descriptor, keymap) = descriptor.to_wallet_descriptor(&secp, network)?;
+        let (descriptor, keymap) = descriptor.into_wallet_descriptor(&secp, network)?;
         database.check_descriptor_checksum(
             KeychainKind::External,
             get_checksum(&descriptor.to_string())?.as_bytes(),
@@ -143,7 +143,7 @@ where
         let (change_descriptor, change_signers) = match change_descriptor {
             Some(desc) => {
                 let (change_descriptor, change_keymap) =
-                    desc.to_wallet_descriptor(&secp, network)?;
+                    desc.into_wallet_descriptor(&secp, network)?;
                 database.check_descriptor_checksum(
                     KeychainKind::Internal,
                     get_checksum(&change_descriptor.to_string())?.as_bytes(),

diff --git a/src/wallet/signer.rs b/src/wallet/signer.rs
index bffc469f30cb9321fb576ca8672e6373551af781..7199dbbd9ad69224e5a27ec4115ce6c342849b21 100644 (file)
--- a/src/wallet/signer.rs
+++ b/src/wallet/signer.rs
@@ -579,7 +579,9 @@ mod signers_container_tests {
         let (prvkey1, _, _) = setup_keys(TPRV0_STR);
         let (prvkey2, _, _) = setup_keys(TPRV1_STR);
         let desc = descriptor!(sh(multi(2, prvkey1, prvkey2))).unwrap();
-        let (_, keymap) = desc.to_wallet_descriptor(&secp, Network::Testnet).unwrap();
+        let (_, keymap) = desc
+            .into_wallet_descriptor(&secp, Network::Testnet)
+            .unwrap();
 
         let signers = SignersContainer::from(keymap);
         assert_eq!(signers.ids().len(), 2);
@@ -690,8 +692,8 @@ mod signers_container_tests {
         let tprv = bip32::ExtendedPrivKey::from_str(tprv).unwrap();
         let tpub = bip32::ExtendedPubKey::from_private(&secp, &tprv);
         let fingerprint = tprv.fingerprint(&secp);
-        let prvkey = (tprv, path.clone()).to_descriptor_key().unwrap();
-        let pubkey = (tpub, path).to_descriptor_key().unwrap();
+        let prvkey = (tprv, path.clone()).into_descriptor_key().unwrap();
+        let pubkey = (tpub, path).into_descriptor_key().unwrap();
 
         (prvkey, pubkey, fingerprint)
     }