global: ivecs

crates/brk_structs/src/groups/address.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use super::{ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, GroupFilter};
 
 #[derive(Default, Clone)]
@@ -42,3 +45,26 @@ impl<T> From<AddressGroups<T>> for AddressGroups<(GroupFilter, T)> {
         }
     }
 }
+
+impl<T: IVecs> IVecs for AddressGroups<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("ge_amount", self.ge_amount.to_tree_node()),
+                ("amount_range", self.amount_range.to_tree_node()),
+                ("lt_amount", self.lt_amount.to_tree_node()),
+            ]
+            .into_iter()
+            .map(|(name, node)| (name.to_string(), node))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self.ge_amount.iter());
+        iter = Box::new(iter.chain(IVecs::iter(&self.amount_range)));
+        iter = Box::new(iter.chain(self.lt_amount.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_address_type.rs

@@ -1,5 +1,8 @@
 use std::ops::{Add, AddAssign};
 
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use super::GroupFilter;
 use crate::OutputType;
 
@@ -192,3 +195,70 @@ impl<T> ByAddressType<Option<T>> {
         });
     }
 }
+
+impl<T: AnyCollectableVec + !IVecs> IVecs for ByAddressType<T> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("p2pk65", &self.p2pk65),
+                ("p2pk33", &self.p2pk33),
+                ("p2pkh", &self.p2pkh),
+                ("p2sh", &self.p2sh),
+                ("p2wpkh", &self.p2wpkh),
+                ("p2wsh", &self.p2wsh),
+                ("p2tr", &self.p2tr),
+                ("p2a", &self.p2a),
+            ]
+            .into_iter()
+            .map(|(name, field)| (name.to_string(), TreeNode::Leaf(field.name().to_string())))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        [
+            &self.p2pk65 as &dyn AnyCollectableVec,
+            &self.p2pk33,
+            &self.p2pkh,
+            &self.p2sh,
+            &self.p2wpkh,
+            &self.p2wsh,
+            &self.p2tr,
+            &self.p2a,
+        ]
+        .into_iter()
+    }
+}
+
+impl<T: IVecs> IVecs for ByAddressType<T> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("p2pk65", &self.p2pk65),
+                ("p2pk33", &self.p2pk33),
+                ("p2pkh", &self.p2pkh),
+                ("p2sh", &self.p2sh),
+                ("p2wpkh", &self.p2wpkh),
+                ("p2wsh", &self.p2wsh),
+                ("p2tr", &self.p2tr),
+                ("p2a", &self.p2a),
+            ]
+            .into_iter()
+            .map(|(name, field)| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self.p2pk65.iter());
+        iter = Box::new(iter.chain(self.p2pk33.iter()));
+        iter = Box::new(iter.chain(self.p2pkh.iter()));
+        iter = Box::new(iter.chain(self.p2sh.iter()));
+        iter = Box::new(iter.chain(self.p2wpkh.iter()));
+        iter = Box::new(iter.chain(self.p2wsh.iter()));
+        iter = Box::new(iter.chain(self.p2tr.iter()));
+        iter = Box::new(iter.chain(self.p2a.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_age_range.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use super::GroupFilter;
 
 #[derive(Default, Clone)]
@@ -132,3 +135,60 @@ impl<T> ByAgeRange<(GroupFilter, T)> {
         .into_iter()
     }
 }
+
+impl<T: IVecs> IVecs for ByAgeRange<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("up_to_1d", &self.up_to_1d),
+                ("1d_to_1w", &self._1d_to_1w),
+                ("1w_to_1m", &self._1w_to_1m),
+                ("1m_to_2m", &self._1m_to_2m),
+                ("2m_to_3m", &self._2m_to_3m),
+                ("3m_to_4m", &self._3m_to_4m),
+                ("4m_to_5m", &self._4m_to_5m),
+                ("5m_to_6m", &self._5m_to_6m),
+                ("6m_to_1y", &self._6m_to_1y),
+                ("1y_to_2y", &self._1y_to_2y),
+                ("2y_to_3y", &self._2y_to_3y),
+                ("3y_to_4y", &self._3y_to_4y),
+                ("4y_to_5y", &self._4y_to_5y),
+                ("5y_to_6y", &self._5y_to_6y),
+                ("6y_to_7y", &self._6y_to_7y),
+                ("7y_to_8y", &self._7y_to_8y),
+                ("8y_to_10y", &self._8y_to_10y),
+                ("10y_to_12y", &self._10y_to_12y),
+                ("12y_to_15y", &self._12y_to_15y),
+                ("from_15y", &self.from_15y),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self.up_to_1d.1.iter());
+        iter = Box::new(iter.chain(self._1d_to_1w.1.iter()));
+        iter = Box::new(iter.chain(self._1w_to_1m.1.iter()));
+        iter = Box::new(iter.chain(self._1m_to_2m.1.iter()));
+        iter = Box::new(iter.chain(self._2m_to_3m.1.iter()));
+        iter = Box::new(iter.chain(self._3m_to_4m.1.iter()));
+        iter = Box::new(iter.chain(self._4m_to_5m.1.iter()));
+        iter = Box::new(iter.chain(self._5m_to_6m.1.iter()));
+        iter = Box::new(iter.chain(self._6m_to_1y.1.iter()));
+        iter = Box::new(iter.chain(self._1y_to_2y.1.iter()));
+        iter = Box::new(iter.chain(self._2y_to_3y.1.iter()));
+        iter = Box::new(iter.chain(self._3y_to_4y.1.iter()));
+        iter = Box::new(iter.chain(self._4y_to_5y.1.iter()));
+        iter = Box::new(iter.chain(self._5y_to_6y.1.iter()));
+        iter = Box::new(iter.chain(self._6y_to_7y.1.iter()));
+        iter = Box::new(iter.chain(self._7y_to_8y.1.iter()));
+        iter = Box::new(iter.chain(self._8y_to_10y.1.iter()));
+        iter = Box::new(iter.chain(self._10y_to_12y.1.iter()));
+        iter = Box::new(iter.chain(self._12y_to_15y.1.iter()));
+        iter = Box::new(iter.chain(self.from_15y.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_amount_range.rs

@@ -1,5 +1,8 @@
 use std::ops::{Add, AddAssign};
 
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use crate::Sats;
 
 use super::GroupFilter;
@@ -259,3 +262,50 @@ where
         self._100k_btc_or_more += rhs._100k_btc_or_more;
     }
 }
+
+impl<T: IVecs> IVecs for ByAmountRange<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("0sats", &self._0sats),
+                ("1sat_to_10sats", &self._1sat_to_10sats),
+                ("10sats_to_100sats", &self._10sats_to_100sats),
+                ("100sats_to_1k_sats", &self._100sats_to_1k_sats),
+                ("1k_sats_to_10k_sats", &self._1k_sats_to_10k_sats),
+                ("10k_sats_to_100k_sats", &self._10k_sats_to_100k_sats),
+                ("100k_sats_to_1m_sats", &self._100k_sats_to_1m_sats),
+                ("1m_sats_to_10m_sats", &self._1m_sats_to_10m_sats),
+                ("10m_sats_to_1btc", &self._10m_sats_to_1btc),
+                ("1btc_to_10btc", &self._1btc_to_10btc),
+                ("10btc_to_100btc", &self._10btc_to_100btc),
+                ("100btc_to_1k_btc", &self._100btc_to_1k_btc),
+                ("1k_btc_to_10k_btc", &self._1k_btc_to_10k_btc),
+                ("10k_btc_to_100k_btc", &self._10k_btc_to_100k_btc),
+                ("100k_btc_or_more", &self._100k_btc_or_more),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self._0sats.1.iter());
+        iter = Box::new(iter.chain(self._1sat_to_10sats.1.iter()));
+        iter = Box::new(iter.chain(self._10sats_to_100sats.1.iter()));
+        iter = Box::new(iter.chain(self._100sats_to_1k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._1k_sats_to_10k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._10k_sats_to_100k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._100k_sats_to_1m_sats.1.iter()));
+        iter = Box::new(iter.chain(self._1m_sats_to_10m_sats.1.iter()));
+        iter = Box::new(iter.chain(self._10m_sats_to_1btc.1.iter()));
+        iter = Box::new(iter.chain(self._1btc_to_10btc.1.iter()));
+        iter = Box::new(iter.chain(self._10btc_to_100btc.1.iter()));
+        iter = Box::new(iter.chain(self._100btc_to_1k_btc.1.iter()));
+        iter = Box::new(iter.chain(self._1k_btc_to_10k_btc.1.iter()));
+        iter = Box::new(iter.chain(self._10k_btc_to_100k_btc.1.iter()));
+        iter = Box::new(iter.chain(self._100k_btc_or_more.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_any_address.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 #[derive(Debug, Default)]
 pub struct ByAnyAddress<T> {
     pub loaded: T,
@@ -10,3 +13,21 @@ impl<T> ByAnyAddress<Option<T>> {
         self.empty.take();
     }
 }
+
+impl<T: IVecs> IVecs for ByAnyAddress<T> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [("loaded", &self.loaded), ("empty", &self.empty)]
+                .into_iter()
+                .map(|(name, field)| (name.to_string(), field.to_tree_node()))
+                .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self.loaded.iter());
+        iter = Box::new(iter.chain(self.empty.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_epoch.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use crate::{HalvingEpoch, Height};
 
 use super::GroupFilter;
@@ -58,3 +61,29 @@ impl<T> ByEpoch<(GroupFilter, T)> {
         [&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1].into_iter()
     }
 }
+
+impl<T: IVecs> IVecs for ByEpoch<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("0", &self._0),
+                ("1", &self._1),
+                ("2", &self._2),
+                ("3", &self._3),
+                ("4", &self._4),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(self._0.1.iter());
+        iter = Box::new(iter.chain(self._1.1.iter()));
+        iter = Box::new(iter.chain(self._2.1.iter()));
+        iter = Box::new(iter.chain(self._3.1.iter()));
+        iter = Box::new(iter.chain(self._4.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_ge_amount.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use crate::Sats;
 
 use super::GroupFilter;
@@ -110,3 +113,46 @@ impl<T> From<ByGreatEqualAmount<T>> for ByGreatEqualAmount<(GroupFilter, T)> {
         }
     }
 }
+
+impl<T: IVecs> IVecs for ByGreatEqualAmount<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("_1sat", &self._1sat),
+                ("_10sats", &self._10sats),
+                ("_100sats", &self._100sats),
+                ("_1k_sats", &self._1k_sats),
+                ("_10k_sats", &self._10k_sats),
+                ("_100k_sats", &self._100k_sats),
+                ("_1m_sats", &self._1m_sats),
+                ("_10m_sats", &self._10m_sats),
+                ("_1btc", &self._1btc),
+                ("_10btc", &self._10btc),
+                ("_100btc", &self._100btc),
+                ("_1k_btc", &self._1k_btc),
+                ("_10k_btc", &self._10k_btc),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self._1sat.1.iter());
+        iter = Box::new(iter.chain(self._10sats.1.iter()));
+        iter = Box::new(iter.chain(self._100sats.1.iter()));
+        iter = Box::new(iter.chain(self._1k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._10k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._100k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._1m_sats.1.iter()));
+        iter = Box::new(iter.chain(self._10m_sats.1.iter()));
+        iter = Box::new(iter.chain(self._1btc.1.iter()));
+        iter = Box::new(iter.chain(self._10btc.1.iter()));
+        iter = Box::new(iter.chain(self._100btc.1.iter()));
+        iter = Box::new(iter.chain(self._1k_btc.1.iter()));
+        iter = Box::new(iter.chain(self._10k_btc.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_lt_amount.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use crate::Sats;
 
 use super::GroupFilter;
@@ -86,3 +89,46 @@ impl<T> From<ByLowerThanAmount<T>> for ByLowerThanAmount<(GroupFilter, T)> {
         }
     }
 }
+
+impl<T: IVecs> IVecs for ByLowerThanAmount<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("10sats", &self._10sats),
+                ("100sats", &self._100sats),
+                ("1k_sats", &self._1k_sats),
+                ("10k_sats", &self._10k_sats),
+                ("100k_sats", &self._100k_sats),
+                ("1m_sats", &self._1m_sats),
+                ("10m_sats", &self._10m_sats),
+                ("1btc", &self._1btc),
+                ("10btc", &self._10btc),
+                ("100btc", &self._100btc),
+                ("1k_btc", &self._1k_btc),
+                ("10k_btc", &self._10k_btc),
+                ("100k_btc", &self._100k_btc),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self._10sats.1.iter());
+        iter = Box::new(iter.chain(self._100sats.1.iter()));
+        iter = Box::new(iter.chain(self._1k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._10k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._100k_sats.1.iter()));
+        iter = Box::new(iter.chain(self._1m_sats.1.iter()));
+        iter = Box::new(iter.chain(self._10m_sats.1.iter()));
+        iter = Box::new(iter.chain(self._1btc.1.iter()));
+        iter = Box::new(iter.chain(self._10btc.1.iter()));
+        iter = Box::new(iter.chain(self._100btc.1.iter()));
+        iter = Box::new(iter.chain(self._1k_btc.1.iter()));
+        iter = Box::new(iter.chain(self._10k_btc.1.iter()));
+        iter = Box::new(iter.chain(self._100k_btc.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_max_age.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use super::GroupFilter;
 
 #[derive(Default, Clone)]
@@ -98,3 +101,56 @@ impl<T> From<ByMaxAge<T>> for ByMaxAge<(GroupFilter, T)> {
         }
     }
 }
+
+impl<T: IVecs> IVecs for ByMaxAge<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("1w", &self._1w),
+                ("1m", &self._1m),
+                ("2m", &self._2m),
+                ("3m", &self._3m),
+                ("4m", &self._4m),
+                ("5m", &self._5m),
+                ("6m", &self._6m),
+                ("1y", &self._1y),
+                ("2y", &self._2y),
+                ("3y", &self._3y),
+                ("4y", &self._4y),
+                ("5y", &self._5y),
+                ("6y", &self._6y),
+                ("7y", &self._7y),
+                ("8y", &self._8y),
+                ("10y", &self._10y),
+                ("12y", &self._12y),
+                ("15y", &self._15y),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self._1w.1.iter());
+        iter = Box::new(iter.chain(self._1m.1.iter()));
+        iter = Box::new(iter.chain(self._2m.1.iter()));
+        iter = Box::new(iter.chain(self._3m.1.iter()));
+        iter = Box::new(iter.chain(self._4m.1.iter()));
+        iter = Box::new(iter.chain(self._5m.1.iter()));
+        iter = Box::new(iter.chain(self._6m.1.iter()));
+        iter = Box::new(iter.chain(self._1y.1.iter()));
+        iter = Box::new(iter.chain(self._2y.1.iter()));
+        iter = Box::new(iter.chain(self._3y.1.iter()));
+        iter = Box::new(iter.chain(self._4y.1.iter()));
+        iter = Box::new(iter.chain(self._5y.1.iter()));
+        iter = Box::new(iter.chain(self._6y.1.iter()));
+        iter = Box::new(iter.chain(self._7y.1.iter()));
+        iter = Box::new(iter.chain(self._8y.1.iter()));
+        iter = Box::new(iter.chain(self._10y.1.iter()));
+        iter = Box::new(iter.chain(self._12y.1.iter()));
+        iter = Box::new(iter.chain(self._15y.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_min_age.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use super::GroupFilter;
 
 #[derive(Default, Clone)]
@@ -98,3 +101,56 @@ impl<T> From<ByMinAge<T>> for ByMinAge<(GroupFilter, T)> {
         }
     }
 }
+
+impl<T: IVecs> IVecs for ByMinAge<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("1d", &self._1d),
+                ("1w", &self._1w),
+                ("1m", &self._1m),
+                ("2m", &self._2m),
+                ("3m", &self._3m),
+                ("4m", &self._4m),
+                ("5m", &self._5m),
+                ("6m", &self._6m),
+                ("1y", &self._1y),
+                ("2y", &self._2y),
+                ("3y", &self._3y),
+                ("4y", &self._4y),
+                ("5y", &self._5y),
+                ("6y", &self._6y),
+                ("7y", &self._7y),
+                ("8y", &self._8y),
+                ("10y", &self._10y),
+                ("12y", &self._12y),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self._1d.1.iter());
+        iter = Box::new(iter.chain(self._1w.1.iter()));
+        iter = Box::new(iter.chain(self._1m.1.iter()));
+        iter = Box::new(iter.chain(self._2m.1.iter()));
+        iter = Box::new(iter.chain(self._3m.1.iter()));
+        iter = Box::new(iter.chain(self._4m.1.iter()));
+        iter = Box::new(iter.chain(self._5m.1.iter()));
+        iter = Box::new(iter.chain(self._6m.1.iter()));
+        iter = Box::new(iter.chain(self._1y.1.iter()));
+        iter = Box::new(iter.chain(self._2y.1.iter()));
+        iter = Box::new(iter.chain(self._3y.1.iter()));
+        iter = Box::new(iter.chain(self._4y.1.iter()));
+        iter = Box::new(iter.chain(self._5y.1.iter()));
+        iter = Box::new(iter.chain(self._6y.1.iter()));
+        iter = Box::new(iter.chain(self._7y.1.iter()));
+        iter = Box::new(iter.chain(self._8y.1.iter()));
+        iter = Box::new(iter.chain(self._10y.1.iter()));
+        iter = Box::new(iter.chain(self._12y.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_spendable_type.rs

@@ -1,5 +1,8 @@
 use std::ops::{Add, AddAssign};
 
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use crate::OutputType;
 
 use super::GroupFilter;
@@ -149,3 +152,42 @@ where
         self.empty += rhs.empty;
     }
 }
+
+impl<T: IVecs> IVecs for BySpendableType<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("p2pk65", &self.p2pk65),
+                ("p2pk33", &self.p2pk33),
+                ("p2pkh", &self.p2pkh),
+                ("p2ms", &self.p2ms),
+                ("p2sh", &self.p2sh),
+                ("p2wpkh", &self.p2wpkh),
+                ("p2wsh", &self.p2wsh),
+                ("p2tr", &self.p2tr),
+                ("p2a", &self.p2a),
+                ("unknown", &self.unknown),
+                ("empty", &self.empty),
+            ]
+            .into_iter()
+            .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self.p2pk65.1.iter());
+        iter = Box::new(iter.chain(self.p2pk33.1.iter()));
+        iter = Box::new(iter.chain(self.p2pkh.1.iter()));
+        iter = Box::new(iter.chain(self.p2ms.1.iter()));
+        iter = Box::new(iter.chain(self.p2sh.1.iter()));
+        iter = Box::new(iter.chain(self.p2wpkh.1.iter()));
+        iter = Box::new(iter.chain(self.p2wsh.1.iter()));
+        iter = Box::new(iter.chain(self.p2tr.1.iter()));
+        iter = Box::new(iter.chain(self.p2a.1.iter()));
+        iter = Box::new(iter.chain(self.unknown.1.iter()));
+        iter = Box::new(iter.chain(self.empty.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_term.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use super::GroupFilter;
 
 #[derive(Default, Clone)]
@@ -26,3 +29,21 @@ impl<T> From<ByTerm<T>> for ByTerm<(GroupFilter, T)> {
         }
     }
 }
+
+impl<T: IVecs> IVecs for ByTerm<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [("short", &self.short), ("long", &self.long)]
+                .into_iter()
+                .map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
+                .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self.short.1.iter());
+        iter = Box::new(iter.chain(self.long.1.iter()));
+        iter
+    }
+}

crates/brk_structs/src/groups/by_type.rs

@@ -1,6 +1,9 @@
 use std::ops::{Add, AddAssign};
 
-use crate::OutputType;
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
+use crate::{GroupFilter, OutputType};
 
 use super::{BySpendableType, ByUnspendableType};
 
@@ -70,3 +73,24 @@ where
         self.unspendable += rhs.unspendable;
     }
 }
+
+// impl<T: IVecs> IVecs for GroupedByType<(GroupFilter, T)> {
+//     fn to_tree_node(&self) -> TreeNode {
+//         TreeNode::Branch(
+//             [
+//                 ("spendable", self.spendable.to_tree_node()),
+//                 ("unspendable", self.unspendable.to_tree_node()),
+//             ]
+//             .into_iter()
+//             .map(|(name, node)| (name.to_string(), node))
+//             .collect(),
+//         )
+//     }
+
+//     fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+//         let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+//             Box::new(self.spendable.iter());
+//         iter = Box::new(iter.chain(self.unspendable.iter()));
+//         iter
+//     }
+// }

crates/brk_structs/src/groups/by_unspendable_type.rs

@@ -1,5 +1,8 @@
 use std::ops::{Add, AddAssign};
 
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 #[derive(Default, Clone, Debug)]
 pub struct ByUnspendableType<T> {
     pub opreturn: T,
@@ -31,3 +34,18 @@ where
         self.opreturn += rhs.opreturn;
     }
 }
+
+impl<T: IVecs> IVecs for ByUnspendableType<T> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [("opreturn", &self.opreturn)]
+                .into_iter()
+                .map(|(name, field)| (name.to_string(), field.to_tree_node()))
+                .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        self.opreturn.iter()
+    }
+}

crates/brk_structs/src/groups/utxo.rs

@@ -1,3 +1,6 @@
+use brk_vecs::{IVecs, TreeNode};
+use vecdb::AnyCollectableVec;
+
 use crate::{
     ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge, ByMinAge,
     BySpendableType, ByTerm, GroupFilter,
@@ -83,3 +86,40 @@ impl<T> From<UTXOGroups<T>> for UTXOGroups<(GroupFilter, T)> {
         }
     }
 }
+
+impl<T: IVecs> IVecs for UTXOGroups<(GroupFilter, T)> {
+    fn to_tree_node(&self) -> TreeNode {
+        TreeNode::Branch(
+            [
+                ("all", self.all.1.to_tree_node()),
+                ("age_range", self.age_range.to_tree_node()),
+                ("epoch", self.epoch.to_tree_node()),
+                ("min_age", self.min_age.to_tree_node()),
+                ("ge_amount", self.ge_amount.to_tree_node()),
+                ("amount_range", self.amount_range.to_tree_node()),
+                ("term", self.term.to_tree_node()),
+                ("type", self._type.to_tree_node()),
+                ("max_age", self.max_age.to_tree_node()),
+                ("lt_amount", self.lt_amount.to_tree_node()),
+            ]
+            .into_iter()
+            .map(|(name, node)| (name.to_string(), node))
+            .collect(),
+        )
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
+            Box::new(self.all.1.iter());
+        iter = Box::new(iter.chain(IVecs::iter(&self.age_range)));
+        iter = Box::new(iter.chain(self.epoch.iter()));
+        iter = Box::new(iter.chain(self.min_age.iter()));
+        iter = Box::new(iter.chain(IVecs::iter(&self.ge_amount)));
+        iter = Box::new(iter.chain(IVecs::iter(&self.amount_range)));
+        iter = Box::new(iter.chain(self.term.iter()));
+        iter = Box::new(iter.chain(self._type.iter()));
+        iter = Box::new(iter.chain(self.max_age.iter()));
+        iter = Box::new(iter.chain(self.lt_amount.iter()));
+        iter
+    }
+}