fix!(chain): Make spk revelation return owned spks

Author: LagginTimes

crates/chain/src/keychain/txout_index.rs

@@ -370,7 +370,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
     /// Return the script that exists under the given `keychain`'s `index`.
     ///
     /// This calls [`SpkTxOutIndex::spk_at_index`] internally.
-    pub fn spk_at_index(&self, keychain: K, index: u32) -> Option<&Script> {
+    pub fn spk_at_index(&self, keychain: K, index: u32) -> Option<ScriptBuf> {
         let descriptor_id = *self.keychains_to_descriptor_ids.get(&keychain)?;
         self.inner.spk_at_index(&(descriptor_id, index))
     }
@@ -630,7 +630,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
     pub fn revealed_spks(
         &self,
         range: impl RangeBounds<K>,
-    ) -> impl DoubleEndedIterator<Item = (&K, u32, &Script)> + Clone {
+    ) -> impl DoubleEndedIterator<Item = (&K, u32, ScriptBuf)> + Clone {
         self.keychains_to_descriptor_ids
             .range(range)
             .flat_map(|(_, descriptor_id)| {
@@ -648,7 +648,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
                             self.keychain_of_desc_id(descriptor_id)
                                 .expect("must have keychain"),
                             *i,
-                            spk.as_script(),
+                            spk.as_script().to_owned(),
                         )
                     })
             })
@@ -658,13 +658,13 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
     pub fn revealed_keychain_spks<'a>(
         &'a self,
         keychain: &'a K,
-    ) -> impl DoubleEndedIterator<Item = (u32, &Script)> + 'a {
+    ) -> impl DoubleEndedIterator<Item = (u32, ScriptBuf)> + 'a {
         self.revealed_spks(keychain..=keychain)
             .map(|(_, i, spk)| (i, spk))
     }
 
     /// Iterate over revealed, but unused, spks of all keychains.
-    pub fn unused_spks(&self) -> impl DoubleEndedIterator<Item = (K, u32, &Script)> + Clone {
+    pub fn unused_spks(&self) -> impl DoubleEndedIterator<Item = (K, u32, ScriptBuf)> + Clone + '_ {
         self.keychains_to_descriptor_ids
             .keys()
             .flat_map(|keychain| {
@@ -675,10 +675,10 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
 
     /// Iterate over revealed, but unused, spks of the given `keychain`.
     /// Returns an empty iterator if the provided keychain doesn't exist.
-    pub fn unused_keychain_spks(
-        &self,
+    pub fn unused_keychain_spks<'a>(
+        &'a self,
         keychain: &K,
-    ) -> impl DoubleEndedIterator<Item = (u32, &Script)> + Clone {
+    ) -> impl DoubleEndedIterator<Item = (u32, ScriptBuf)> + Clone + 'a {
         let desc_id = self
             .keychains_to_descriptor_ids
             .get(keychain)
@@ -909,8 +909,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
             let spk = self
                 .inner
                 .spk_at_index(&(descriptor_id, next_index))
-                .expect("script must already be stored")
-                .to_owned();
+                .expect("script must already be stored");
             (next_index, spk)
         });
         debug_assert_eq!(new_spks.next(), None, "must only reveal one spk");
@@ -931,10 +930,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
     /// has used all scripts up to the derivation bounds, then the last derived script pubkey will
     /// be returned.
     pub fn next_unused_spk(&mut self, keychain: &K) -> (Option<(u32, ScriptBuf)>, ChangeSet<K>) {
-        let next_unused_spk = self
-            .unused_keychain_spks(keychain)
-            .next()
-            .map(|(i, spk)| (i, spk.to_owned()));
+        let next_unused_spk = self.unused_keychain_spks(keychain).next();
         if next_unused_spk.is_some() {
             (next_unused_spk, Default::default())
         } else {

crates/chain/src/spk_client.rs

@@ -195,11 +195,10 @@ impl SyncRequest {
         index: &crate::keychain::KeychainTxOutIndex<K>,
         spk_range: impl RangeBounds<K>,
     ) -> Self {
-        use alloc::borrow::ToOwned;
         self.chain_spks(
             index
                 .revealed_spks(spk_range)
-                .map(|(_, _, spk)| spk.to_owned())
+                .map(|(_, _, spk)| spk)
                 .collect::<Vec<_>>(),
         )
     }

crates/chain/src/spk_txout_index.rs

@@ -174,8 +174,8 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
     /// Returns the script that has been inserted at the `index`.
     ///
     /// If that index hasn't been inserted yet, it will return `None`.
-    pub fn spk_at_index(&self, index: &I) -> Option<&Script> {
-        self.spks.get(index).map(|s| s.as_script())
+    pub fn spk_at_index(&self, index: &I) -> Option<ScriptBuf> {
+        self.spks.get(index).cloned()
     }
 
     /// The script pubkeys that are being tracked by the index.
@@ -215,7 +215,10 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
     /// let unused_change_spks =
     ///     txout_index.unused_spks((change_index, u32::MIN)..(change_index, u32::MAX));
     /// ```
-    pub fn unused_spks<R>(&self, range: R) -> impl DoubleEndedIterator<Item = (&I, &Script)> + Clone
+    pub fn unused_spks<R>(
+        &self,
+        range: R,
+    ) -> impl DoubleEndedIterator<Item = (&I, ScriptBuf)> + Clone
     where
         R: RangeBounds<I>,
     {

crates/wallet/src/wallet/mod.rs

@@ -849,7 +849,7 @@ impl Wallet {
             .unused_keychain_spks(&keychain)
             .map(move |(index, spk)| AddressInfo {
                 index,
-                address: Address::from_script(spk, self.network).expect("must have address form"),
+                address: Address::from_script(&spk, self.network).expect("must have address form"),
                 keychain,
             })
     }

example-crates/example_cli/src/lib.rs

@@ -493,7 +493,7 @@ where
                         false => Keychain::External,
                     };
                     for (spk_i, spk) in index.revealed_keychain_spks(&target_keychain) {
-                        let address = Address::from_script(spk, network)
+                        let address = Address::from_script(&spk, network)
                             .expect("should always be able to derive address");
                         println!(
                             "{:?} {} used:{}",

example-crates/example_electrum/src/main.rs

@@ -227,7 +227,7 @@ fn main() -> anyhow::Result<()> {
                 let all_spks = graph
                     .index
                     .revealed_spks(..)
-                    .map(|(k, i, spk)| (k.to_owned(), i, spk.to_owned()))
+                    .map(|(k, i, spk)| (k.to_owned(), i, spk))
                     .collect::<Vec<_>>();
                 request = request.chain_spks(all_spks.into_iter().map(|(k, spk_i, spk)| {
                     eprint!("Scanning {}: {}", k, spk_i);
@@ -238,7 +238,7 @@ fn main() -> anyhow::Result<()> {
                 let unused_spks = graph
                     .index
                     .unused_spks()
-                    .map(|(k, i, spk)| (k, i, spk.to_owned()))
+                    .map(|(k, i, spk)| (k, i, spk))
                     .collect::<Vec<_>>();
                 request =
                     request.chain_spks(unused_spks.into_iter().map(move |(k, spk_i, spk)| {

example-crates/example_esplora/src/main.rs

@@ -245,7 +245,7 @@ fn main() -> anyhow::Result<()> {
                     let all_spks = graph
                         .index
                         .revealed_spks(..)
-                        .map(|(k, i, spk)| (k.to_owned(), i, spk.to_owned()))
+                        .map(|(k, i, spk)| (k.to_owned(), i, spk))
                         .collect::<Vec<_>>();
                     request = request.chain_spks(all_spks.into_iter().map(|(k, i, spk)| {
                         eprint!("scanning {}:{}", k, i);
@@ -258,7 +258,7 @@ fn main() -> anyhow::Result<()> {
                     let unused_spks = graph
                         .index
                         .unused_spks()
-                        .map(|(k, i, spk)| (k, i, spk.to_owned()))
+                        .map(|(k, i, spk)| (k, i, spk))
                         .collect::<Vec<_>>();
                     request =
                         request.chain_spks(unused_spks.into_iter().map(move |(k, i, spk)| {