tr: move TapTreeIter into taptree module

We are going to move TapTree into the module (hence the name), and
before we can do this we need to move the iterator.

Author: heap-coder

src/descriptor/mod.rs

@@ -42,7 +42,7 @@ pub use self::bare::{Bare, Pkh};
 pub use self::segwitv0::{Wpkh, Wsh, WshInner};
 pub use self::sh::{Sh, ShInner};
 pub use self::sortedmulti::SortedMultiVec;
-pub use self::tr::{TapTree, Tr};
+pub use self::tr::{TapTree, TapTreeIter, TapTreeIterItem, Tr};
 
 pub mod checksum;
 mod key;

src/descriptor/tr/mod.rs

@@ -28,7 +28,7 @@ use crate::{
 
 mod taptree;
 
-pub use self::taptree::TapTreeIterItem;
+pub use self::taptree::{TapTreeIter, TapTreeIterItem};
 
 /// A Taproot Tree representation.
 // Hidden leaves are not yet supported in descriptor spec. Conceptually, it should
@@ -132,7 +132,7 @@ impl<Pk: MiniscriptKey> TapTree<Pk> {
 
     /// Iterates over all miniscripts in DFS walk order compatible with the
     /// PSBT requirements (BIP 371).
-    pub fn iter(&self) -> TapTreeIter<Pk> { TapTreeIter { stack: vec![(0, self)] } }
+    pub fn iter(&self) -> TapTreeIter<Pk> { TapTreeIter::from_tree(self) }
 
     // Helper function to translate keys
     fn translate_helper<T>(&self, t: &mut T) -> Result<TapTree<T::TargetPk>, TranslateErr<T::Error>>
@@ -201,7 +201,7 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
     pub fn iter_scripts(&self) -> TapTreeIter<Pk> {
         match self.tree {
             Some(ref t) => t.iter(),
-            None => TapTreeIter { stack: vec![] },
+            None => TapTreeIter::empty(),
         }
     }
 
@@ -451,48 +451,6 @@ impl Tr<DefiniteDescriptorKey> {
     }
 }
 
-/// Iterator for Taproot structures
-/// Yields a pair of (depth, miniscript) in a depth first walk
-/// For example, this tree:
-///                                     - N0 -
-///                                    /     \\
-///                                   N1      N2
-///                                  /  \    /  \\
-///                                 A    B  C   N3
-///                                            /  \\
-///                                           D    E
-/// would yield (2, A), (2, B), (2,C), (3, D), (3, E).
-///
-#[derive(Debug, Clone)]
-pub struct TapTreeIter<'a, Pk: MiniscriptKey> {
-    stack: Vec<(u8, &'a TapTree<Pk>)>,
-}
-
-impl<Pk: MiniscriptKey> TapTreeIter<'_, Pk> {
-    /// Helper function to return an empty iterator from Descriptor::tap_tree_iter.
-    pub(super) fn empty() -> Self { Self { stack: vec![] } }
-}
-
-impl<'a, Pk> Iterator for TapTreeIter<'a, Pk>
-where
-    Pk: MiniscriptKey + 'a,
-{
-    type Item = TapTreeIterItem<'a, Pk>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some((depth, last)) = self.stack.pop() {
-            match *last {
-                TapTree::Tree { ref left, ref right, height: _ } => {
-                    self.stack.push((depth + 1, right));
-                    self.stack.push((depth + 1, left));
-                }
-                TapTree::Leaf(ref ms) => return Some(TapTreeIterItem { node: ms, depth }),
-            }
-        }
-        None
-    }
-}
-
 impl<Pk: FromStrKey> core::str::FromStr for Tr<Pk> {
     type Err = Error;
 

src/descriptor/tr/taptree.rs

@@ -2,18 +2,66 @@
 
 use bitcoin::taproot::{LeafVersion, TapLeafHash};
 
+use super::TapTree;
 use crate::miniscript::context::Tap;
+use crate::prelude::Vec;
 use crate::sync::Arc;
 use crate::{Miniscript, MiniscriptKey, ToPublicKey};
 
+/// Iterator over the leaves of a Taptree.
+///
+/// Yields a pair of (depth, miniscript) in a depth first walk
+/// For example, this tree:
+///                                     - N0 -
+///                                    /     \\
+///                                   N1      N2
+///                                  /  \    /  \\
+///                                 A    B  C   N3
+///                                            /  \\
+///                                           D    E
+/// would yield (2, A), (2, B), (2,C), (3, D), (3, E).
+///
+#[derive(Debug, Clone)]
+pub struct TapTreeIter<'a, Pk: MiniscriptKey> {
+    stack: Vec<(u8, &'a TapTree<Pk>)>,
+}
+
+impl<'tr, Pk: MiniscriptKey> TapTreeIter<'tr, Pk> {
+    /// An empty iterator.
+    pub fn empty() -> Self { Self { stack: vec![] } }
+
+    /// An iterator over a given tree.
+    pub(super) fn from_tree(tree: &'tr TapTree<Pk>) -> Self { Self { stack: vec![(0, tree)] } }
+}
+
+impl<'a, Pk> Iterator for TapTreeIter<'a, Pk>
+where
+    Pk: MiniscriptKey + 'a,
+{
+    type Item = TapTreeIterItem<'a, Pk>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some((depth, last)) = self.stack.pop() {
+            match *last {
+                TapTree::Tree { ref left, ref right, height: _ } => {
+                    self.stack.push((depth + 1, right));
+                    self.stack.push((depth + 1, left));
+                }
+                TapTree::Leaf(ref ms) => return Some(TapTreeIterItem { node: ms, depth }),
+            }
+        }
+        None
+    }
+}
+
 /// Iterator over all of the leaves of a Taproot tree.
 ///
 /// If there is no tree (i.e. this is a keyspend-only Taproot descriptor)
 /// then the iterator will yield nothing.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct TapTreeIterItem<'tr, Pk: MiniscriptKey> {
-    pub(super) node: &'tr Arc<Miniscript<Pk, Tap>>,
-    pub(super) depth: u8,
+    node: &'tr Arc<Miniscript<Pk, Tap>>,
+    depth: u8,
 }
 
 impl<'tr, Pk: MiniscriptKey> TapTreeIterItem<'tr, Pk> {