global: snapshot

crates/brk_state/src/cohorts/address.rs

@@ -0,0 +1,90 @@
+use std::{
+    ops::{Deref, DerefMut},
+    path::Path,
+};
+
+use brk_core::{Dollars, Height, Result};
+
+use crate::{CohortStateTrait, SupplyState, UnrealizedState};
+
+use super::CohortState;
+
+#[derive(Clone)]
+pub struct AddressCohortState {
+    pub address_count: usize,
+    pub inner: CohortState,
+}
+
+impl CohortStateTrait for AddressCohortState {
+    fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
+        Ok(Self {
+            address_count: 0,
+            inner: CohortState::default_and_import(path, name, compute_dollars)?,
+        })
+    }
+
+    fn reset_single_iteration_values(&mut self) {
+        self.inner.reset_single_iteration_values();
+    }
+
+    fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.inner.increment(supply_state, price);
+    }
+
+    fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.inner.decrement(supply_state, price);
+    }
+
+    fn decrement_price_to_amount(&mut self, supply_state: &SupplyState, price: Dollars) {
+        self.inner.decrement_price_to_amount(supply_state, price);
+    }
+
+    fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.inner.receive(supply_state, price);
+    }
+
+    fn send(
+        &mut self,
+        supply_state: &SupplyState,
+        current_price: Option<Dollars>,
+        prev_price: Option<Dollars>,
+        blocks_old: usize,
+        days_old: f64,
+        older_than_hour: bool,
+    ) {
+        self.inner.send(
+            supply_state,
+            current_price,
+            prev_price,
+            blocks_old,
+            days_old,
+            older_than_hour,
+        );
+    }
+
+    fn compute_unrealized_states(
+        &self,
+        height_price: Dollars,
+        date_price: Option<Dollars>,
+    ) -> (UnrealizedState, Option<UnrealizedState>) {
+        self.inner
+            .compute_unrealized_states(height_price, date_price)
+    }
+
+    fn commit(&mut self, height: Height) -> Result<()> {
+        self.inner.commit(height)
+    }
+}
+
+impl Deref for AddressCohortState {
+    type Target = CohortState;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl DerefMut for AddressCohortState {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}

crates/brk_state/src/cohorts/common.rs

@@ -2,9 +2,7 @@ use std::{cmp::Ordering, path::Path};
 
 use brk_core::{CheckedSub, Dollars, Height, Result, Sats};
 
-use crate::{PriceToAmount, UnrealizedState};
-
-use super::{RealizedState, SupplyState};
+use crate::{CohortStateTrait, PriceToAmount, RealizedState, SupplyState, UnrealizedState};
 
 #[derive(Clone)]
 pub struct CohortState {
@@ -15,8 +13,8 @@ pub struct CohortState {
     pub price_to_amount: PriceToAmount,
 }
 
-impl CohortState {
-    pub fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
+impl CohortStateTrait for CohortState {
+    fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
         Ok(Self {
             supply: SupplyState::default(),
             realized: compute_dollars.then_some(RealizedState::NAN),
@@ -26,7 +24,7 @@ impl CohortState {
         })
     }
 
-    pub fn reset_single_iteration_values(&mut self) {
+    fn reset_single_iteration_values(&mut self) {
         self.satdays_destroyed = Sats::ZERO;
         self.satblocks_destroyed = Sats::ZERO;
         if let Some(realized) = self.realized.as_mut() {
@@ -34,7 +32,7 @@ impl CohortState {
         }
     }
 
-    pub fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+    fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
         self.supply += supply_state;
 
         if supply_state.value > Sats::ZERO {
@@ -46,7 +44,7 @@ impl CohortState {
         }
     }
 
-    pub fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+    fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
         self.supply -= supply_state;
 
         if supply_state.value > Sats::ZERO {
@@ -66,7 +64,7 @@ impl CohortState {
         }
     }
 
-    pub fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+    fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
         self.supply += supply_state;
 
         if supply_state.value > Sats::ZERO {
@@ -78,7 +76,7 @@ impl CohortState {
         }
     }
 
-    pub fn send(
+    fn send(
         &mut self,
         supply_state: &SupplyState,
         current_price: Option<Dollars>,
@@ -87,24 +85,26 @@ impl CohortState {
         days_old: f64,
         older_than_hour: bool,
     ) {
-        self.supply -= supply_state;
+        if supply_state.utxos > 0 {
+            self.supply -= supply_state;
 
-        if supply_state.value > Sats::ZERO {
-            self.satblocks_destroyed += supply_state.value * blocks_old;
+            if supply_state.value > Sats::ZERO {
+                self.satblocks_destroyed += supply_state.value * blocks_old;
 
-            self.satdays_destroyed +=
-                Sats::from((u64::from(supply_state.value) as f64 * days_old).floor() as u64);
+                self.satdays_destroyed +=
+                    Sats::from((u64::from(supply_state.value) as f64 * days_old).floor() as u64);
 
-            if let Some(realized) = self.realized.as_mut() {
-                let current_price = current_price.unwrap();
-                let prev_price = prev_price.unwrap();
-                realized.send(supply_state, current_price, prev_price, older_than_hour);
-                self.decrement_price_to_amount(supply_state, prev_price);
+                if let Some(realized) = self.realized.as_mut() {
+                    let current_price = current_price.unwrap();
+                    let prev_price = prev_price.unwrap();
+                    realized.send(supply_state, current_price, prev_price, older_than_hour);
+                    self.decrement_price_to_amount(supply_state, prev_price);
+                }
             }
         }
     }
 
-    pub fn compute_unrealized_states(
+    fn compute_unrealized_states(
         &self,
         height_price: Dollars,
         date_price: Option<Dollars>,
@@ -166,7 +166,7 @@ impl CohortState {
         (height_unrealized_state, date_unrealized_state)
     }
 
-    pub fn commit(&mut self, height: Height) -> Result<()> {
+    fn commit(&mut self, height: Height) -> Result<()> {
         self.price_to_amount.flush(height)
     }
 }

crates/brk_state/src/cohorts/mod.rs

@@ -0,0 +1,9 @@
+mod address;
+mod common;
+mod r#trait;
+mod utxo;
+
+pub use address::*;
+pub use common::*;
+pub use r#trait::*;
+pub use utxo::*;

crates/brk_state/src/cohorts/trait.rs

@@ -0,0 +1,29 @@
+use std::path::Path;
+
+use brk_core::{Dollars, Height, Result};
+
+use crate::{SupplyState, UnrealizedState};
+
+pub trait CohortStateTrait: Sized {
+    fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self>;
+    fn reset_single_iteration_values(&mut self);
+    fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>);
+    fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>);
+    fn decrement_price_to_amount(&mut self, supply_state: &SupplyState, price: Dollars);
+    fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>);
+    fn send(
+        &mut self,
+        supply_state: &SupplyState,
+        current_price: Option<Dollars>,
+        prev_price: Option<Dollars>,
+        blocks_old: usize,
+        days_old: f64,
+        older_than_hour: bool,
+    );
+    fn compute_unrealized_states(
+        &self,
+        height_price: Dollars,
+        date_price: Option<Dollars>,
+    ) -> (UnrealizedState, Option<UnrealizedState>);
+    fn commit(&mut self, height: Height) -> Result<()>;
+}

crates/brk_state/src/cohorts/utxo.rs

@@ -0,0 +1,72 @@
+use std::path::Path;
+
+use brk_core::{Dollars, Height, Result};
+use derive_deref::{Deref, DerefMut};
+
+use crate::{CohortStateTrait, SupplyState, UnrealizedState};
+
+use super::CohortState;
+
+#[derive(Clone, Deref, DerefMut)]
+pub struct UTXOCohortState(CohortState);
+
+impl CohortStateTrait for UTXOCohortState {
+    fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
+        Ok(Self(CohortState::default_and_import(
+            path,
+            name,
+            compute_dollars,
+        )?))
+    }
+
+    fn reset_single_iteration_values(&mut self) {
+        self.0.reset_single_iteration_values();
+    }
+
+    fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.0.increment(supply_state, price);
+    }
+
+    fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.0.decrement(supply_state, price);
+    }
+
+    fn decrement_price_to_amount(&mut self, supply_state: &SupplyState, price: Dollars) {
+        self.0.decrement_price_to_amount(supply_state, price);
+    }
+
+    fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.0.receive(supply_state, price);
+    }
+
+    fn send(
+        &mut self,
+        supply_state: &SupplyState,
+        current_price: Option<Dollars>,
+        prev_price: Option<Dollars>,
+        blocks_old: usize,
+        days_old: f64,
+        older_than_hour: bool,
+    ) {
+        self.0.send(
+            supply_state,
+            current_price,
+            prev_price,
+            blocks_old,
+            days_old,
+            older_than_hour,
+        );
+    }
+
+    fn compute_unrealized_states(
+        &self,
+        height_price: Dollars,
+        date_price: Option<Dollars>,
+    ) -> (UnrealizedState, Option<UnrealizedState>) {
+        self.0.compute_unrealized_states(height_price, date_price)
+    }
+
+    fn commit(&mut self, height: Height) -> Result<()> {
+        self.0.commit(height)
+    }
+}

crates/brk_state/src/hot.rs

@@ -1,142 +0,0 @@
-pub struct OneShotSats {
-    pub price_paid_state: PricePaidState,
-    pub unrealized_block_state: UnrealizedState,
-    pub unrealized_date_state: Option<UnrealizedState>,
-}
-
-pub struct UnrealizedState {
-    supply_in_profit: Sats,
-    // supply_in_loss: Sats,
-    unrealized_profit: Dollars,
-    unrealized_loss: Dollars,
-}
-
-// Why option ?
-#[derive(Default, Debug)]
-pub struct PricePaidState {
-    pp_p5: Option<Dollars>,
-    pp_p10: Option<Dollars>,
-    pp_p15: Option<Dollars>,
-    pp_p20: Option<Dollars>,
-    pp_p25: Option<Dollars>,
-    pp_p30: Option<Dollars>,
-    pp_p35: Option<Dollars>,
-    pp_p40: Option<Dollars>,
-    pp_p45: Option<Dollars>,
-    pp_median: Option<Dollars>,
-    pp_p55: Option<Dollars>,
-    pp_p60: Option<Dollars>,
-    pp_p65: Option<Dollars>,
-    pp_p70: Option<Dollars>,
-    pp_p75: Option<Dollars>,
-    pp_p80: Option<Dollars>,
-    pp_p85: Option<Dollars>,
-    pp_p90: Option<Dollars>,
-    pp_p95: Option<Dollars>,
-
-    processed_amount: Sats,
-}
-
-pub struct PricePaidStateFull {
-    pp_p1: Option<Dollars>,
-    pp_p2: Option<Dollars>,
-    pp_p3: Option<Dollars>,
-    pp_p4: Option<Dollars>,
-    pp_p5: Option<Dollars>,
-    pp_p6: Option<Dollars>,
-    pp_p7: Option<Dollars>,
-    pp_p8: Option<Dollars>,
-    pp_p9: Option<Dollars>,
-    pp_p10: Option<Dollars>,
-    pp_p11: Option<Dollars>,
-    pp_p12: Option<Dollars>,
-    pp_p13: Option<Dollars>,
-    pp_p14: Option<Dollars>,
-    pp_p15: Option<Dollars>,
-    pp_p16: Option<Dollars>,
-    pp_p17: Option<Dollars>,
-    pp_p18: Option<Dollars>,
-    pp_p19: Option<Dollars>,
-    pp_p20: Option<Dollars>,
-    pp_p21: Option<Dollars>,
-    pp_p22: Option<Dollars>,
-    pp_p23: Option<Dollars>,
-    pp_p24: Option<Dollars>,
-    pp_p25: Option<Dollars>,
-    pp_p26: Option<Dollars>,
-    pp_p27: Option<Dollars>,
-    pp_p28: Option<Dollars>,
-    pp_p29: Option<Dollars>,
-    pp_p30: Option<Dollars>,
-    pp_p31: Option<Dollars>,
-    pp_p32: Option<Dollars>,
-    pp_p33: Option<Dollars>,
-    pp_p34: Option<Dollars>,
-    pp_p35: Option<Dollars>,
-    pp_p36: Option<Dollars>,
-    pp_p37: Option<Dollars>,
-    pp_p38: Option<Dollars>,
-    pp_p39: Option<Dollars>,
-    pp_p40: Option<Dollars>,
-    pp_p41: Option<Dollars>,
-    pp_p42: Option<Dollars>,
-    pp_p43: Option<Dollars>,
-    pp_p44: Option<Dollars>,
-    pp_p45: Option<Dollars>,
-    pp_p46: Option<Dollars>,
-    pp_p47: Option<Dollars>,
-    pp_p48: Option<Dollars>,
-    pp_p49: Option<Dollars>,
-    pp_p50: Option<Dollars>,
-    pp_p51: Option<Dollars>,
-    pp_p52: Option<Dollars>,
-    pp_p53: Option<Dollars>,
-    pp_p54: Option<Dollars>,
-    pp_p55: Option<Dollars>,
-    pp_p56: Option<Dollars>,
-    pp_p57: Option<Dollars>,
-    pp_p58: Option<Dollars>,
-    pp_p59: Option<Dollars>,
-    pp_p60: Option<Dollars>,
-    pp_p61: Option<Dollars>,
-    pp_p62: Option<Dollars>,
-    pp_p63: Option<Dollars>,
-    pp_p64: Option<Dollars>,
-    pp_p65: Option<Dollars>,
-    pp_p66: Option<Dollars>,
-    pp_p67: Option<Dollars>,
-    pp_p68: Option<Dollars>,
-    pp_p69: Option<Dollars>,
-    pp_p70: Option<Dollars>,
-    pp_p71: Option<Dollars>,
-    pp_p72: Option<Dollars>,
-    pp_p73: Option<Dollars>,
-    pp_p74: Option<Dollars>,
-    pp_p75: Option<Dollars>,
-    pp_p76: Option<Dollars>,
-    pp_p77: Option<Dollars>,
-    pp_p78: Option<Dollars>,
-    pp_p79: Option<Dollars>,
-    pp_p80: Option<Dollars>,
-    pp_p81: Option<Dollars>,
-    pp_p82: Option<Dollars>,
-    pp_p83: Option<Dollars>,
-    pp_p84: Option<Dollars>,
-    pp_p85: Option<Dollars>,
-    pp_p86: Option<Dollars>,
-    pp_p87: Option<Dollars>,
-    pp_p88: Option<Dollars>,
-    pp_p89: Option<Dollars>,
-    pp_p90: Option<Dollars>,
-    pp_p91: Option<Dollars>,
-    pp_p92: Option<Dollars>,
-    pp_p93: Option<Dollars>,
-    pp_p94: Option<Dollars>,
-    pp_p95: Option<Dollars>,
-    pp_p96: Option<Dollars>,
-    pp_p97: Option<Dollars>,
-    pp_p98: Option<Dollars>,
-    pp_p99: Option<Dollars>,
-
-    processed_amount: Sats,
-}

crates/brk_state/src/lib.rs

@@ -4,21 +4,17 @@
 // #![doc = "```"]
 
 mod block;
-mod cohort;
-mod outputs;
-mod realized;
-// mod hot;
+mod cohorts;
 mod price_to_amount;
+mod realized;
 mod supply;
 mod transacted;
 mod unrealized;
 
 pub use block::*;
-pub use cohort::*;
-pub use outputs::*;
-pub use realized::*;
-pub use unrealized::*;
-// pub use hot::*;
+pub use cohorts::*;
 pub use price_to_amount::*;
+pub use realized::*;
 pub use supply::*;
 pub use transacted::*;
+pub use unrealized::*;

crates/brk_state/src/outputs/by_date_range.rs

@@ -1,126 +0,0 @@
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByDateRange<T> {
-    pub start_to_1d: T,
-    pub _1d_to_1w: T,
-    pub _1w_to_1m: T,
-    pub _1m_to_2m: T,
-    pub _2m_to_3m: T,
-    pub _3m_to_4m: T,
-    pub _4m_to_5m: T,
-    pub _5m_to_6m: T,
-    pub _6m_to_1y: T,
-    pub _1y_to_2y: T,
-    pub _2y_to_3y: T,
-    pub _3y_to_4y: T,
-    pub _4y_to_5y: T,
-    pub _5y_to_6y: T,
-    pub _6y_to_7y: T,
-    pub _7y_to_8y: T,
-    pub _8y_to_10y: T,
-    pub _10y_to_15y: T,
-    pub _15y_to_end: T,
-}
-
-impl<T> From<OutputsByDateRange<T>> for OutputsByDateRange<(OutputFilter, T)> {
-    fn from(value: OutputsByDateRange<T>) -> Self {
-        Self {
-            start_to_1d: (OutputFilter::To(1), value.start_to_1d),
-            _1d_to_1w: (OutputFilter::Range(1..7), value._1d_to_1w),
-            _1w_to_1m: (OutputFilter::Range(7..30), value._1w_to_1m),
-            _1m_to_2m: (OutputFilter::Range(30..2 * 30), value._1m_to_2m),
-            _2m_to_3m: (OutputFilter::Range(2 * 30..3 * 30), value._2m_to_3m),
-            _3m_to_4m: (OutputFilter::Range(3 * 30..4 * 30), value._3m_to_4m),
-            _4m_to_5m: (OutputFilter::Range(4 * 30..5 * 30), value._4m_to_5m),
-            _5m_to_6m: (OutputFilter::Range(5 * 30..6 * 30), value._5m_to_6m),
-            _6m_to_1y: (OutputFilter::Range(6 * 30..365), value._6m_to_1y),
-            _1y_to_2y: (OutputFilter::Range(365..2 * 365), value._1y_to_2y),
-            _2y_to_3y: (OutputFilter::Range(2 * 365..3 * 365), value._2y_to_3y),
-            _3y_to_4y: (OutputFilter::Range(3 * 365..4 * 365), value._3y_to_4y),
-            _4y_to_5y: (OutputFilter::Range(4 * 365..5 * 365), value._4y_to_5y),
-            _5y_to_6y: (OutputFilter::Range(5 * 365..6 * 365), value._5y_to_6y),
-            _6y_to_7y: (OutputFilter::Range(6 * 365..7 * 365), value._6y_to_7y),
-            _7y_to_8y: (OutputFilter::Range(7 * 365..8 * 365), value._7y_to_8y),
-            _8y_to_10y: (OutputFilter::Range(8 * 365..10 * 365), value._8y_to_10y),
-            _10y_to_15y: (OutputFilter::Range(10 * 365..15 * 365), value._10y_to_15y),
-            _15y_to_end: (OutputFilter::From(15 * 365), value._15y_to_end),
-        }
-    }
-}
-
-impl<T> OutputsByDateRange<T> {
-    pub fn as_vec(&mut self) -> [&T; 19] {
-        [
-            &self.start_to_1d,
-            &self._1d_to_1w,
-            &self._1w_to_1m,
-            &self._1m_to_2m,
-            &self._2m_to_3m,
-            &self._3m_to_4m,
-            &self._4m_to_5m,
-            &self._5m_to_6m,
-            &self._6m_to_1y,
-            &self._1y_to_2y,
-            &self._2y_to_3y,
-            &self._3y_to_4y,
-            &self._4y_to_5y,
-            &self._5y_to_6y,
-            &self._6y_to_7y,
-            &self._7y_to_8y,
-            &self._8y_to_10y,
-            &self._10y_to_15y,
-            &self._15y_to_end,
-        ]
-    }
-
-    pub fn as_mut_vec(&mut self) -> [&mut T; 19] {
-        [
-            &mut self.start_to_1d,
-            &mut self._1d_to_1w,
-            &mut self._1w_to_1m,
-            &mut self._1m_to_2m,
-            &mut self._2m_to_3m,
-            &mut self._3m_to_4m,
-            &mut self._4m_to_5m,
-            &mut self._5m_to_6m,
-            &mut self._6m_to_1y,
-            &mut self._1y_to_2y,
-            &mut self._2y_to_3y,
-            &mut self._3y_to_4y,
-            &mut self._4y_to_5y,
-            &mut self._5y_to_6y,
-            &mut self._6y_to_7y,
-            &mut self._7y_to_8y,
-            &mut self._8y_to_10y,
-            &mut self._10y_to_15y,
-            &mut self._15y_to_end,
-        ]
-    }
-}
-
-impl<T> OutputsByDateRange<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 19] {
-        [
-            &self.start_to_1d.1,
-            &self._1d_to_1w.1,
-            &self._1w_to_1m.1,
-            &self._1m_to_2m.1,
-            &self._2m_to_3m.1,
-            &self._3m_to_4m.1,
-            &self._4m_to_5m.1,
-            &self._5m_to_6m.1,
-            &self._6m_to_1y.1,
-            &self._1y_to_2y.1,
-            &self._2y_to_3y.1,
-            &self._3y_to_4y.1,
-            &self._4y_to_5y.1,
-            &self._5y_to_6y.1,
-            &self._6y_to_7y.1,
-            &self._7y_to_8y.1,
-            &self._8y_to_10y.1,
-            &self._10y_to_15y.1,
-            &self._15y_to_end.1,
-        ]
-    }
-}

crates/brk_state/src/outputs/by_epoch.rs

@@ -1,59 +0,0 @@
-use brk_core::{HalvingEpoch, Height};
-
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByEpoch<T> {
-    pub _0: T,
-    pub _1: T,
-    pub _2: T,
-    pub _3: T,
-    pub _4: T,
-}
-
-impl<T> From<OutputsByEpoch<T>> for OutputsByEpoch<(OutputFilter, T)> {
-    fn from(value: OutputsByEpoch<T>) -> Self {
-        Self {
-            _0: (OutputFilter::Epoch(HalvingEpoch::new(0)), value._0),
-            _1: (OutputFilter::Epoch(HalvingEpoch::new(1)), value._1),
-            _2: (OutputFilter::Epoch(HalvingEpoch::new(2)), value._2),
-            _3: (OutputFilter::Epoch(HalvingEpoch::new(3)), value._3),
-            _4: (OutputFilter::Epoch(HalvingEpoch::new(4)), value._4),
-        }
-    }
-}
-
-impl<T> OutputsByEpoch<T> {
-    pub fn as_mut_vec(&mut self) -> [&mut T; 5] {
-        [
-            &mut self._0,
-            &mut self._1,
-            &mut self._2,
-            &mut self._3,
-            &mut self._4,
-        ]
-    }
-
-    pub fn mut_vec_from_height(&mut self, height: Height) -> &mut T {
-        let epoch = HalvingEpoch::from(height);
-        if epoch == HalvingEpoch::new(0) {
-            &mut self._0
-        } else if epoch == HalvingEpoch::new(1) {
-            &mut self._1
-        } else if epoch == HalvingEpoch::new(2) {
-            &mut self._2
-        } else if epoch == HalvingEpoch::new(3) {
-            &mut self._3
-        } else if epoch == HalvingEpoch::new(4) {
-            &mut self._4
-        } else {
-            todo!("")
-        }
-    }
-}
-
-impl<T> OutputsByEpoch<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 5] {
-        [&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1]
-    }
-}

crates/brk_state/src/outputs/by_from_date.rs

@@ -1,98 +0,0 @@
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByFromDate<T> {
-    pub _1d: T,
-    pub _1w: T,
-    pub _1m: T,
-    pub _2m: T,
-    pub _3m: T,
-    pub _4m: T,
-    pub _5m: T,
-    pub _6m: T,
-    pub _1y: T,
-    pub _2y: T,
-    pub _3y: T,
-    pub _4y: T,
-    pub _5y: T,
-    pub _6y: T,
-    pub _7y: T,
-    pub _8y: T,
-    pub _10y: T,
-    pub _15y: T,
-}
-
-impl<T> OutputsByFromDate<T> {
-    pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
-        [
-            &mut self._1d,
-            &mut self._1w,
-            &mut self._1m,
-            &mut self._2m,
-            &mut self._3m,
-            &mut self._4m,
-            &mut self._5m,
-            &mut self._6m,
-            &mut self._1y,
-            &mut self._2y,
-            &mut self._3y,
-            &mut self._4y,
-            &mut self._5y,
-            &mut self._6y,
-            &mut self._7y,
-            &mut self._8y,
-            &mut self._10y,
-            &mut self._15y,
-        ]
-    }
-}
-
-impl<T> OutputsByFromDate<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 18] {
-        [
-            &self._1d.1,
-            &self._1w.1,
-            &self._1m.1,
-            &self._2m.1,
-            &self._3m.1,
-            &self._4m.1,
-            &self._5m.1,
-            &self._6m.1,
-            &self._1y.1,
-            &self._2y.1,
-            &self._3y.1,
-            &self._4y.1,
-            &self._5y.1,
-            &self._6y.1,
-            &self._7y.1,
-            &self._8y.1,
-            &self._10y.1,
-            &self._15y.1,
-        ]
-    }
-}
-
-impl<T> From<OutputsByFromDate<T>> for OutputsByFromDate<(OutputFilter, T)> {
-    fn from(value: OutputsByFromDate<T>) -> Self {
-        Self {
-            _1d: (OutputFilter::From(1), value._1d),
-            _1w: (OutputFilter::From(7), value._1w),
-            _1m: (OutputFilter::From(30), value._1m),
-            _2m: (OutputFilter::From(2 * 30), value._2m),
-            _3m: (OutputFilter::From(3 * 30), value._3m),
-            _4m: (OutputFilter::From(4 * 30), value._4m),
-            _5m: (OutputFilter::From(5 * 30), value._5m),
-            _6m: (OutputFilter::From(6 * 30), value._6m),
-            _1y: (OutputFilter::From(365), value._1y),
-            _2y: (OutputFilter::From(2 * 365), value._2y),
-            _3y: (OutputFilter::From(3 * 365), value._3y),
-            _4y: (OutputFilter::From(4 * 365), value._4y),
-            _5y: (OutputFilter::From(5 * 365), value._5y),
-            _6y: (OutputFilter::From(6 * 365), value._6y),
-            _7y: (OutputFilter::From(7 * 365), value._7y),
-            _8y: (OutputFilter::From(8 * 365), value._8y),
-            _10y: (OutputFilter::From(10 * 365), value._10y),
-            _15y: (OutputFilter::From(15 * 365), value._15y),
-        }
-    }
-}

crates/brk_state/src/outputs/by_from_size.rs

@@ -1,50 +0,0 @@
-use brk_core::Sats;
-
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByFromSize<T> {
-    pub _1_000sats: T,
-    pub _1btc: T,
-    pub _10btc: T,
-    pub _100btc: T,
-}
-
-impl<T> OutputsByFromSize<T> {
-    pub fn as_mut_vec(&mut self) -> [&mut T; 4] {
-        [
-            &mut self._1_000sats,
-            &mut self._1btc,
-            &mut self._10btc,
-            &mut self._100btc,
-        ]
-    }
-}
-
-impl<T> OutputsByFromSize<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 4] {
-        [
-            &self._1_000sats.1,
-            &self._1btc.1,
-            &self._10btc.1,
-            &self._100btc.1,
-        ]
-    }
-}
-
-impl<T> From<OutputsByFromSize<T>> for OutputsByFromSize<(OutputFilter, T)> {
-    fn from(value: OutputsByFromSize<T>) -> Self {
-        Self {
-            _1_000sats: (OutputFilter::From(1_000), value._1_000sats),
-            _1btc: (OutputFilter::From(usize::from(Sats::ONE_BTC)), value._1btc),
-            _10btc: (
-                OutputFilter::From(usize::from(10 * Sats::ONE_BTC)),
-                value._10btc,
-            ),
-            _100btc: (
-                OutputFilter::From(usize::from(100 * Sats::ONE_BTC)),
-                value._100btc,
-            ),
-        }
-    }
-}

crates/brk_state/src/outputs/by_size_range.rs

@@ -1,178 +0,0 @@
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsBySizeRange<T> {
-    pub _0sats: T,
-    pub from_1sat_to_10sats: T,
-    pub from_10sats_to_100sats: T,
-    pub from_100sats_to_1_000sats: T,
-    pub from_1_000sats_to_10_000sats: T,
-    pub from_10_000sats_to_100_000sats: T,
-    pub from_100_000sats_to_1_000_000sats: T,
-    pub from_1_000_000sats_to_10_000_000sats: T,
-    pub from_10_000_000sats_to_1btc: T,
-    pub from_1btc_to_10btc: T,
-    pub from_10btc_to_100btc: T,
-    pub from_100btc_to_1_000btc: T,
-    pub from_1_000btc_to_10_000btc: T,
-    pub from_10_000btc_to_100_000btc: T,
-    pub from_100_000btc: T,
-}
-
-impl<T> From<OutputsBySizeRange<T>> for OutputsBySizeRange<(OutputFilter, T)> {
-    fn from(value: OutputsBySizeRange<T>) -> Self {
-        #[allow(clippy::inconsistent_digit_grouping)]
-        Self {
-            _0sats: (OutputFilter::To(1), value._0sats),
-            from_1sat_to_10sats: (OutputFilter::Range(1..10), value.from_1sat_to_10sats),
-            from_10sats_to_100sats: (OutputFilter::Range(10..100), value.from_10sats_to_100sats),
-            from_100sats_to_1_000sats: (
-                OutputFilter::Range(100..1_000),
-                value.from_100sats_to_1_000sats,
-            ),
-            from_1_000sats_to_10_000sats: (
-                OutputFilter::Range(1_000..10_000),
-                value.from_1_000sats_to_10_000sats,
-            ),
-            from_10_000sats_to_100_000sats: (
-                OutputFilter::Range(10_000..100_000),
-                value.from_10_000sats_to_100_000sats,
-            ),
-            from_100_000sats_to_1_000_000sats: (
-                OutputFilter::Range(100_000..1_000_000),
-                value.from_100_000sats_to_1_000_000sats,
-            ),
-            from_1_000_000sats_to_10_000_000sats: (
-                OutputFilter::Range(1_000_000..10_000_000),
-                value.from_1_000_000sats_to_10_000_000sats,
-            ),
-            from_10_000_000sats_to_1btc: (
-                OutputFilter::Range(10_000_000..1_00_000_000),
-                value.from_10_000_000sats_to_1btc,
-            ),
-            from_1btc_to_10btc: (
-                OutputFilter::Range(1_00_000_000..10_00_000_000),
-                value.from_1btc_to_10btc,
-            ),
-            from_10btc_to_100btc: (
-                OutputFilter::Range(10_00_000_000..100_00_000_000),
-                value.from_10btc_to_100btc,
-            ),
-            from_100btc_to_1_000btc: (
-                OutputFilter::Range(100_00_000_000..1_000_00_000_000),
-                value.from_100btc_to_1_000btc,
-            ),
-            from_1_000btc_to_10_000btc: (
-                OutputFilter::Range(1_000_00_000_000..10_000_00_000_000),
-                value.from_1_000btc_to_10_000btc,
-            ),
-            from_10_000btc_to_100_000btc: (
-                OutputFilter::Range(10_000_00_000_000..100_000_00_000_000),
-                value.from_10_000btc_to_100_000btc,
-            ),
-            from_100_000btc: (
-                OutputFilter::From(100_000_00_000_000),
-                value.from_100_000btc,
-            ),
-        }
-    }
-}
-
-impl<T> OutputsBySizeRange<T> {
-    #[allow(clippy::inconsistent_digit_grouping)]
-    pub fn get_mut(&mut self, group: usize) -> &mut T {
-        if group == 0 {
-            &mut self._0sats
-        } else if group == 1 {
-            &mut self.from_1sat_to_10sats
-        } else if group == 10 {
-            &mut self.from_10sats_to_100sats
-        } else if group == 100 {
-            &mut self.from_100sats_to_1_000sats
-        } else if group == 1_000 {
-            &mut self.from_1_000sats_to_10_000sats
-        } else if group == 10_000 {
-            &mut self.from_10_000sats_to_100_000sats
-        } else if group == 100_000 {
-            &mut self.from_100_000sats_to_1_000_000sats
-        } else if group == 1_000_000 {
-            &mut self.from_1_000_000sats_to_10_000_000sats
-        } else if group == 10_000_000 {
-            &mut self.from_10_000_000sats_to_1btc
-        } else if group == 1_00_000_000 {
-            &mut self.from_1btc_to_10btc
-        } else if group == 10_00_000_000 {
-            &mut self.from_10btc_to_100btc
-        } else if group == 100_00_000_000 {
-            &mut self.from_100btc_to_1_000btc
-        } else if group == 1_000_00_000_000 {
-            &mut self.from_1_000btc_to_10_000btc
-        } else if group == 10_000_00_000_000 {
-            &mut self.from_10_000btc_to_100_000btc
-        } else {
-            &mut self.from_100_000btc
-        }
-    }
-
-    pub fn as_vec(&self) -> [&T; 15] {
-        [
-            &self._0sats,
-            &self.from_1sat_to_10sats,
-            &self.from_10sats_to_100sats,
-            &self.from_100sats_to_1_000sats,
-            &self.from_1_000sats_to_10_000sats,
-            &self.from_10_000sats_to_100_000sats,
-            &self.from_100_000sats_to_1_000_000sats,
-            &self.from_1_000_000sats_to_10_000_000sats,
-            &self.from_10_000_000sats_to_1btc,
-            &self.from_1btc_to_10btc,
-            &self.from_10btc_to_100btc,
-            &self.from_100btc_to_1_000btc,
-            &self.from_1_000btc_to_10_000btc,
-            &self.from_10_000btc_to_100_000btc,
-            &self.from_100_000btc,
-        ]
-    }
-
-    pub fn as_mut_vec(&mut self) -> [&mut T; 15] {
-        [
-            &mut self._0sats,
-            &mut self.from_1sat_to_10sats,
-            &mut self.from_10sats_to_100sats,
-            &mut self.from_100sats_to_1_000sats,
-            &mut self.from_1_000sats_to_10_000sats,
-            &mut self.from_10_000sats_to_100_000sats,
-            &mut self.from_100_000sats_to_1_000_000sats,
-            &mut self.from_1_000_000sats_to_10_000_000sats,
-            &mut self.from_10_000_000sats_to_1btc,
-            &mut self.from_1btc_to_10btc,
-            &mut self.from_10btc_to_100btc,
-            &mut self.from_100btc_to_1_000btc,
-            &mut self.from_1_000btc_to_10_000btc,
-            &mut self.from_10_000btc_to_100_000btc,
-            &mut self.from_100_000btc,
-        ]
-    }
-}
-
-impl<T> OutputsBySizeRange<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 15] {
-        [
-            &self._0sats.1,
-            &self.from_1sat_to_10sats.1,
-            &self.from_10sats_to_100sats.1,
-            &self.from_100sats_to_1_000sats.1,
-            &self.from_1_000sats_to_10_000sats.1,
-            &self.from_10_000sats_to_100_000sats.1,
-            &self.from_100_000sats_to_1_000_000sats.1,
-            &self.from_1_000_000sats_to_10_000_000sats.1,
-            &self.from_10_000_000sats_to_1btc.1,
-            &self.from_1btc_to_10btc.1,
-            &self.from_10btc_to_100btc.1,
-            &self.from_100btc_to_1_000btc.1,
-            &self.from_1_000btc_to_10_000btc.1,
-            &self.from_10_000btc_to_100_000btc.1,
-            &self.from_100_000btc.1,
-        ]
-    }
-}

crates/brk_state/src/outputs/by_spendable_type.rs

@@ -1,181 +0,0 @@
-use std::ops::{Add, AddAssign};
-
-use brk_core::OutputType;
-
-use super::OutputFilter;
-
-#[derive(Default, Clone, Debug)]
-pub struct OutputsBySpendableType<T> {
-    pub p2pk65: T,
-    pub p2pk33: T,
-    pub p2pkh: T,
-    pub p2ms: T,
-    pub p2sh: T,
-    pub p2wpkh: T,
-    pub p2wsh: T,
-    pub p2tr: T,
-    pub p2a: T,
-    pub unknown: T,
-    pub empty: T,
-}
-
-impl<T> OutputsBySpendableType<T> {
-    // pub fn get(&self, output_type: OutputType) -> &T {
-    //     match output_type {
-    //         OutputType::P2PK65 => &self.p2pk65,
-    //         OutputType::P2PK33 => &self.p2pk33,
-    //         OutputType::P2PKH => &self.p2pkh,
-    //         OutputType::P2MS => &self.p2ms,
-    //         OutputType::P2SH => &self.p2sh,
-    //         OutputType::P2WPKH => &self.p2wpkh,
-    //         OutputType::P2WSH => &self.p2wsh,
-    //         OutputType::P2TR => &self.p2tr,
-    //         OutputType::P2A => &self.p2a,
-    //         OutputType::Unknown => &self.unknown,
-    //         OutputType::Empty => &self.empty,
-    //         _ => unreachable!(),
-    //     }
-    // }
-
-    pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
-        match output_type {
-            OutputType::P2PK65 => &mut self.p2pk65,
-            OutputType::P2PK33 => &mut self.p2pk33,
-            OutputType::P2PKH => &mut self.p2pkh,
-            OutputType::P2MS => &mut self.p2ms,
-            OutputType::P2SH => &mut self.p2sh,
-            OutputType::P2WPKH => &mut self.p2wpkh,
-            OutputType::P2WSH => &mut self.p2wsh,
-            OutputType::P2TR => &mut self.p2tr,
-            OutputType::P2A => &mut self.p2a,
-            OutputType::Unknown => &mut self.unknown,
-            OutputType::Empty => &mut self.empty,
-            _ => unreachable!(),
-        }
-    }
-
-    // pub fn as_vec(&self) -> [&T; 11] {
-    //     [
-    //         &self.p2pk65,
-    //         &self.p2pk33,
-    //         &self.p2pkh,
-    //         &self.p2ms,
-    //         &self.p2sh,
-    //         &self.p2wpkh,
-    //         &self.p2wsh,
-    //         &self.p2tr,
-    //         &self.p2a,
-    //         &self.unknown,
-    //         &self.empty,
-    //     ]
-    // }
-
-    pub fn as_mut_vec(&mut self) -> [&mut T; 11] {
-        [
-            &mut self.p2pk65,
-            &mut self.p2pk33,
-            &mut self.p2pkh,
-            &mut self.p2ms,
-            &mut self.p2sh,
-            &mut self.p2wpkh,
-            &mut self.p2wsh,
-            &mut self.p2tr,
-            &mut self.p2a,
-            &mut self.unknown,
-            &mut self.empty,
-        ]
-    }
-
-    pub fn as_typed_vec(&self) -> [(OutputType, &T); 11] {
-        [
-            (OutputType::P2PK65, &self.p2pk65),
-            (OutputType::P2PK33, &self.p2pk33),
-            (OutputType::P2PKH, &self.p2pkh),
-            (OutputType::P2MS, &self.p2ms),
-            (OutputType::P2SH, &self.p2sh),
-            (OutputType::P2WPKH, &self.p2wpkh),
-            (OutputType::P2WSH, &self.p2wsh),
-            (OutputType::P2TR, &self.p2tr),
-            (OutputType::P2A, &self.p2a),
-            (OutputType::Unknown, &self.unknown),
-            (OutputType::Empty, &self.empty),
-        ]
-    }
-}
-
-impl<T> OutputsBySpendableType<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 11] {
-        [
-            &self.p2pk65.1,
-            &self.p2pk33.1,
-            &self.p2pkh.1,
-            &self.p2ms.1,
-            &self.p2sh.1,
-            &self.p2wpkh.1,
-            &self.p2wsh.1,
-            &self.p2tr.1,
-            &self.p2a.1,
-            &self.unknown.1,
-            &self.empty.1,
-        ]
-    }
-}
-
-impl<T> From<OutputsBySpendableType<T>> for OutputsBySpendableType<(OutputFilter, T)> {
-    fn from(value: OutputsBySpendableType<T>) -> Self {
-        Self {
-            p2pk65: (OutputFilter::Type(OutputType::P2PK65), value.p2pk65),
-            p2pk33: (OutputFilter::Type(OutputType::P2PK33), value.p2pk33),
-            p2pkh: (OutputFilter::Type(OutputType::P2PKH), value.p2pkh),
-            p2ms: (OutputFilter::Type(OutputType::P2MS), value.p2ms),
-            p2sh: (OutputFilter::Type(OutputType::P2SH), value.p2sh),
-            p2wpkh: (OutputFilter::Type(OutputType::P2WPKH), value.p2wpkh),
-            p2wsh: (OutputFilter::Type(OutputType::P2WSH), value.p2wsh),
-            p2tr: (OutputFilter::Type(OutputType::P2TR), value.p2tr),
-            p2a: (OutputFilter::Type(OutputType::P2A), value.p2a),
-            unknown: (OutputFilter::Type(OutputType::Unknown), value.unknown),
-            empty: (OutputFilter::Type(OutputType::Empty), value.empty),
-        }
-    }
-}
-
-impl<T> Add for OutputsBySpendableType<T>
-where
-    T: Add<Output = T>,
-{
-    type Output = Self;
-    fn add(self, rhs: Self) -> Self::Output {
-        Self {
-            p2pk65: self.p2pk65 + rhs.p2pk65,
-            p2pk33: self.p2pk33 + rhs.p2pk33,
-            p2pkh: self.p2pkh + rhs.p2pkh,
-            p2ms: self.p2ms + rhs.p2ms,
-            p2sh: self.p2sh + rhs.p2sh,
-            p2wpkh: self.p2wpkh + rhs.p2wpkh,
-            p2wsh: self.p2wsh + rhs.p2wsh,
-            p2tr: self.p2tr + rhs.p2tr,
-            p2a: self.p2a + rhs.p2a,
-            unknown: self.unknown + rhs.unknown,
-            empty: self.empty + rhs.empty,
-        }
-    }
-}
-
-impl<T> AddAssign for OutputsBySpendableType<T>
-where
-    T: AddAssign,
-{
-    fn add_assign(&mut self, rhs: Self) {
-        self.p2pk65 += rhs.p2pk65;
-        self.p2pk33 += rhs.p2pk33;
-        self.p2pkh += rhs.p2pkh;
-        self.p2ms += rhs.p2ms;
-        self.p2sh += rhs.p2sh;
-        self.p2wpkh += rhs.p2wpkh;
-        self.p2wsh += rhs.p2wsh;
-        self.p2tr += rhs.p2tr;
-        self.p2a += rhs.p2a;
-        self.unknown += rhs.unknown;
-        self.empty += rhs.empty;
-    }
-}

crates/brk_state/src/outputs/by_term.rs

@@ -1,28 +0,0 @@
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByTerm<T> {
-    pub short: T,
-    pub long: T,
-}
-
-impl<T> OutputsByTerm<T> {
-    pub fn as_mut_vec(&mut self) -> [&mut T; 2] {
-        [&mut self.short, &mut self.long]
-    }
-}
-
-impl<T> OutputsByTerm<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 2] {
-        [&self.short.1, &self.long.1]
-    }
-}
-
-impl<T> From<OutputsByTerm<T>> for OutputsByTerm<(OutputFilter, T)> {
-    fn from(value: OutputsByTerm<T>) -> Self {
-        Self {
-            short: (OutputFilter::To(5 * 30), value.short),
-            long: (OutputFilter::From(5 * 30), value.long),
-        }
-    }
-}

crates/brk_state/src/outputs/by_type.rs

@@ -1,86 +0,0 @@
-use std::ops::{Add, AddAssign};
-
-use brk_core::OutputType;
-
-use super::{OutputsBySpendableType, OutputsByUnspendableType};
-
-#[derive(Default, Clone, Debug)]
-pub struct OutputsByType<T> {
-    pub spendable: OutputsBySpendableType<T>,
-    pub unspendable: OutputsByUnspendableType<T>,
-}
-
-impl<T> OutputsByType<T> {
-    pub fn get(&self, output_type: OutputType) -> &T {
-        match output_type {
-            OutputType::P2PK65 => &self.spendable.p2pk65,
-            OutputType::P2PK33 => &self.spendable.p2pk33,
-            OutputType::P2PKH => &self.spendable.p2pkh,
-            OutputType::P2MS => &self.spendable.p2ms,
-            OutputType::P2SH => &self.spendable.p2sh,
-            OutputType::P2WPKH => &self.spendable.p2wpkh,
-            OutputType::P2WSH => &self.spendable.p2wsh,
-            OutputType::P2TR => &self.spendable.p2tr,
-            OutputType::P2A => &self.spendable.p2a,
-            OutputType::Empty => &self.spendable.empty,
-            OutputType::Unknown => &self.spendable.unknown,
-            OutputType::OpReturn => &self.unspendable.opreturn,
-        }
-    }
-
-    pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
-        match output_type {
-            OutputType::P2PK65 => &mut self.spendable.p2pk65,
-            OutputType::P2PK33 => &mut self.spendable.p2pk33,
-            OutputType::P2PKH => &mut self.spendable.p2pkh,
-            OutputType::P2MS => &mut self.spendable.p2ms,
-            OutputType::P2SH => &mut self.spendable.p2sh,
-            OutputType::P2WPKH => &mut self.spendable.p2wpkh,
-            OutputType::P2WSH => &mut self.spendable.p2wsh,
-            OutputType::P2TR => &mut self.spendable.p2tr,
-            OutputType::P2A => &mut self.spendable.p2a,
-            OutputType::Unknown => &mut self.spendable.unknown,
-            OutputType::Empty => &mut self.spendable.empty,
-            OutputType::OpReturn => &mut self.unspendable.opreturn,
-        }
-    }
-
-    // pub fn as_vec(&self) -> Vec<&T> {
-    // self.spendable
-    //     .as_vec()
-    //     .into_iter()
-    //     .chain(self.unspendable.as_vec())
-    //     .collect::<Vec<_>>()
-    // }
-
-    // pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
-    //     self.spendable
-    //         .as_mut_vec()
-    //         .into_iter()
-    //         .chain(self.unspendable.as_mut_vec())
-    //         .collect::<Vec<_>>()
-    // }
-}
-
-impl<T> Add for OutputsByType<T>
-where
-    T: Add<Output = T>,
-{
-    type Output = Self;
-    fn add(self, rhs: Self) -> Self::Output {
-        Self {
-            spendable: self.spendable + rhs.spendable,
-            unspendable: self.unspendable + rhs.unspendable,
-        }
-    }
-}
-
-impl<T> AddAssign for OutputsByType<T>
-where
-    T: AddAssign,
-{
-    fn add_assign(&mut self, rhs: Self) {
-        self.spendable += rhs.spendable;
-        self.unspendable += rhs.unspendable;
-    }
-}

crates/brk_state/src/outputs/by_unspendable_type.rs

@@ -1,33 +0,0 @@
-use std::ops::{Add, AddAssign};
-
-#[derive(Default, Clone, Debug)]
-pub struct OutputsByUnspendableType<T> {
-    pub opreturn: T,
-}
-
-impl<T> OutputsByUnspendableType<T> {
-    pub fn as_vec(&self) -> [&T; 1] {
-        [&self.opreturn]
-    }
-}
-
-impl<T> Add for OutputsByUnspendableType<T>
-where
-    T: Add<Output = T>,
-{
-    type Output = Self;
-    fn add(self, rhs: Self) -> Self::Output {
-        Self {
-            opreturn: self.opreturn + rhs.opreturn,
-        }
-    }
-}
-
-impl<T> AddAssign for OutputsByUnspendableType<T>
-where
-    T: AddAssign,
-{
-    fn add_assign(&mut self, rhs: Self) {
-        self.opreturn += rhs.opreturn;
-    }
-}

crates/brk_state/src/outputs/by_up_to_date.rs

@@ -1,98 +0,0 @@
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByUpToDate<T> {
-    pub _1d: T,
-    pub _1w: T,
-    pub _1m: T,
-    pub _2m: T,
-    pub _3m: T,
-    pub _4m: T,
-    pub _5m: T,
-    pub _6m: T,
-    pub _1y: T,
-    pub _2y: T,
-    pub _3y: T,
-    pub _4y: T,
-    pub _5y: T,
-    pub _6y: T,
-    pub _7y: T,
-    pub _8y: T,
-    pub _10y: T,
-    pub _15y: T,
-}
-
-impl<T> OutputsByUpToDate<T> {
-    pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
-        [
-            &mut self._1d,
-            &mut self._1w,
-            &mut self._1m,
-            &mut self._2m,
-            &mut self._3m,
-            &mut self._4m,
-            &mut self._5m,
-            &mut self._6m,
-            &mut self._1y,
-            &mut self._2y,
-            &mut self._3y,
-            &mut self._4y,
-            &mut self._5y,
-            &mut self._6y,
-            &mut self._7y,
-            &mut self._8y,
-            &mut self._10y,
-            &mut self._15y,
-        ]
-    }
-}
-
-impl<T> OutputsByUpToDate<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 18] {
-        [
-            &self._1d.1,
-            &self._1w.1,
-            &self._1m.1,
-            &self._2m.1,
-            &self._3m.1,
-            &self._4m.1,
-            &self._5m.1,
-            &self._6m.1,
-            &self._1y.1,
-            &self._2y.1,
-            &self._3y.1,
-            &self._4y.1,
-            &self._5y.1,
-            &self._6y.1,
-            &self._7y.1,
-            &self._8y.1,
-            &self._10y.1,
-            &self._15y.1,
-        ]
-    }
-}
-
-impl<T> From<OutputsByUpToDate<T>> for OutputsByUpToDate<(OutputFilter, T)> {
-    fn from(value: OutputsByUpToDate<T>) -> Self {
-        Self {
-            _1d: (OutputFilter::To(1), value._1d),
-            _1w: (OutputFilter::To(7), value._1w),
-            _1m: (OutputFilter::To(30), value._1m),
-            _2m: (OutputFilter::To(2 * 30), value._2m),
-            _3m: (OutputFilter::To(3 * 30), value._3m),
-            _4m: (OutputFilter::To(4 * 30), value._4m),
-            _5m: (OutputFilter::To(5 * 30), value._5m),
-            _6m: (OutputFilter::To(6 * 30), value._6m),
-            _1y: (OutputFilter::To(365), value._1y),
-            _2y: (OutputFilter::To(2 * 365), value._2y),
-            _3y: (OutputFilter::To(3 * 365), value._3y),
-            _4y: (OutputFilter::To(4 * 365), value._4y),
-            _5y: (OutputFilter::To(5 * 365), value._5y),
-            _6y: (OutputFilter::To(6 * 365), value._6y),
-            _7y: (OutputFilter::To(7 * 365), value._7y),
-            _8y: (OutputFilter::To(8 * 365), value._8y),
-            _10y: (OutputFilter::To(10 * 365), value._10y),
-            _15y: (OutputFilter::To(15 * 365), value._15y),
-        }
-    }
-}

crates/brk_state/src/outputs/by_up_to_size.rs

@@ -1,54 +0,0 @@
-use brk_core::Sats;
-
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByUpToSize<T> {
-    pub _1_000sats: T,
-    pub _10_000sats: T,
-    pub _1btc: T,
-    pub _10btc: T,
-    pub _100btc: T,
-}
-
-impl<T> OutputsByUpToSize<T> {
-    pub fn as_mut_vec(&mut self) -> [&mut T; 5] {
-        [
-            &mut self._1_000sats,
-            &mut self._10_000sats,
-            &mut self._1btc,
-            &mut self._10btc,
-            &mut self._100btc,
-        ]
-    }
-}
-
-impl<T> OutputsByUpToSize<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 5] {
-        [
-            &self._1_000sats.1,
-            &self._10_000sats.1,
-            &self._1btc.1,
-            &self._10btc.1,
-            &self._100btc.1,
-        ]
-    }
-}
-
-impl<T> From<OutputsByUpToSize<T>> for OutputsByUpToSize<(OutputFilter, T)> {
-    fn from(value: OutputsByUpToSize<T>) -> Self {
-        Self {
-            _1_000sats: (OutputFilter::To(1_000), value._1_000sats),
-            _10_000sats: (OutputFilter::To(10_000), value._10_000sats),
-            _1btc: (OutputFilter::To(usize::from(Sats::ONE_BTC)), value._1btc),
-            _10btc: (
-                OutputFilter::To(usize::from(10 * Sats::ONE_BTC)),
-                value._10btc,
-            ),
-            _100btc: (
-                OutputFilter::To(usize::from(100 * Sats::ONE_BTC)),
-                value._100btc,
-            ),
-        }
-    }
-}

crates/brk_state/src/outputs/by_value.rs

@@ -1,37 +0,0 @@
-#[derive(Default, Clone)]
-pub struct OutputsByValue<T> {
-    pub up_to_1cent: T,
-    pub from_1c_to_10c: T,
-    pub from_10c_to_1d: T,
-    pub from_1d_to_10d: T,
-    pub from_10usd_to_100usd: T,
-    pub from_100usd_to_1_000usd: T,
-    pub from_1_000usd_to_10_000usd: T,
-    pub from_10_000usd_to_100_000usd: T,
-    pub from_100_000usd_to_1_000_000usd: T,
-    pub from_1_000_000usd_to_10_000_000usd: T,
-    pub from_10_000_000usd_to_100_000_000usd: T,
-    pub from_100_000_000usd_to_1_000_000_000usd: T,
-    pub from_1_000_000_000usd: T,
-    // ...
-}
-
-impl<T> OutputsByValue<T> {
-    pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
-        vec![
-            &mut self.up_to_1cent,
-            &mut self.from_1c_to_10c,
-            &mut self.from_10c_to_1d,
-            &mut self.from_1d_to_10d,
-            &mut self.from_10usd_to_100usd,
-            &mut self.from_100usd_to_1_000usd,
-            &mut self.from_1_000usd_to_10_000usd,
-            &mut self.from_10_000usd_to_100_000usd,
-            &mut self.from_100_000usd_to_1_000_000usd,
-            &mut self.from_1_000_000usd_to_10_000_000usd,
-            &mut self.from_10_000_000usd_to_100_000_000usd,
-            &mut self.from_100_000_000usd_to_1_000_000_000usd,
-            &mut self.from_1_000_000_000usd,
-        ]
-    }
-}

crates/brk_state/src/outputs/filter.rs

@@ -1,51 +0,0 @@
-use std::ops::Range;
-
-use brk_core::{HalvingEpoch, OutputType};
-
-#[derive(Debug, Clone)]
-pub enum OutputFilter {
-    All,
-    To(usize),
-    Range(Range<usize>),
-    From(usize),
-    Epoch(HalvingEpoch),
-    Type(OutputType),
-}
-
-impl OutputFilter {
-    pub fn contains(&self, value: usize) -> bool {
-        match self {
-            OutputFilter::All => true,
-            OutputFilter::To(to) => *to > value,
-            OutputFilter::From(from) => *from <= value,
-            OutputFilter::Range(r) => r.contains(&value),
-            OutputFilter::Epoch(_) => false,
-            OutputFilter::Type(_) => false,
-        }
-    }
-
-    pub fn includes(&self, other: &OutputFilter) -> bool {
-        match self {
-            OutputFilter::All => true,
-            OutputFilter::To(to) => match other {
-                OutputFilter::All => false,
-                OutputFilter::To(to2) => to >= to2,
-                OutputFilter::Range(range) => range.end <= *to,
-                OutputFilter::From(_) => false,
-                OutputFilter::Epoch(_) => false,
-                OutputFilter::Type(_) => false,
-            },
-            OutputFilter::From(from) => match other {
-                OutputFilter::All => false,
-                OutputFilter::To(_) => false,
-                OutputFilter::Range(range) => range.start >= *from,
-                OutputFilter::From(from2) => from <= from2,
-                OutputFilter::Epoch(_) => false,
-                OutputFilter::Type(_) => false,
-            },
-            OutputFilter::Range(_) => false,
-            OutputFilter::Epoch(_) => false,
-            OutputFilter::Type(_) => false,
-        }
-    }
-}

crates/brk_state/src/outputs/mod.rs

@@ -1,120 +0,0 @@
-mod by_date_range;
-mod by_epoch;
-mod by_from_date;
-mod by_from_size;
-mod by_size_range;
-mod by_spendable_type;
-mod by_term;
-mod by_type;
-mod by_unspendable_type;
-mod by_up_to_date;
-mod by_up_to_size;
-// mod by_value;
-mod filter;
-
-pub use by_date_range::*;
-pub use by_epoch::*;
-pub use by_from_date::*;
-pub use by_from_size::*;
-pub use by_size_range::*;
-pub use by_spendable_type::*;
-pub use by_term::*;
-pub use by_type::*;
-pub use by_unspendable_type::*;
-pub use by_up_to_date::*;
-pub use by_up_to_size::*;
-// pub use by_value::*;
-pub use filter::*;
-
-#[derive(Default, Clone)]
-pub struct Outputs<T> {
-    pub all: T,
-    pub by_date_range: OutputsByDateRange<T>,
-    pub by_epoch: OutputsByEpoch<T>,
-    pub by_from_date: OutputsByFromDate<T>,
-    pub by_from_size: OutputsByFromSize<T>,
-    pub by_size_range: OutputsBySizeRange<T>,
-    pub by_term: OutputsByTerm<T>,
-    pub by_type: OutputsBySpendableType<T>,
-    pub by_up_to_date: OutputsByUpToDate<T>,
-    pub by_up_to_size: OutputsByUpToSize<T>,
-    // Needs whole UTXO set, TODO later
-    // pub by_value: OutputsByValue<T>,
-}
-
-impl<T> Outputs<T> {
-    pub fn as_mut_vecs(&mut self) -> Vec<&mut T> {
-        [&mut self.all]
-            .into_iter()
-            .chain(self.by_term.as_mut_vec())
-            .chain(self.by_up_to_date.as_mut_vec())
-            .chain(self.by_from_date.as_mut_vec())
-            .chain(self.by_from_size.as_mut_vec())
-            .chain(self.by_date_range.as_mut_vec())
-            .chain(self.by_epoch.as_mut_vec())
-            .chain(self.by_size_range.as_mut_vec())
-            .chain(self.by_up_to_size.as_mut_vec())
-            .chain(self.by_type.as_mut_vec())
-            // .chain(self.by_value.as_mut_vec())
-            .collect::<Vec<_>>()
-    }
-
-    pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> {
-        self.by_date_range
-            .as_mut_vec()
-            .into_iter()
-            .chain(self.by_epoch.as_mut_vec())
-            .chain(self.by_size_range.as_mut_vec())
-            .chain(self.by_type.as_mut_vec())
-            // .chain(self.by_value.as_mut_vec())
-            .collect::<Vec<_>>()
-    }
-
-    pub fn as_mut_overlapping_vecs(&mut self) -> Vec<&mut T> {
-        [&mut self.all]
-            .into_iter()
-            .chain(self.by_term.as_mut_vec())
-            .chain(self.by_up_to_date.as_mut_vec())
-            .chain(self.by_from_date.as_mut_vec())
-            .chain(self.by_up_to_size.as_mut_vec())
-            .chain(self.by_from_size.as_mut_vec())
-            .collect::<Vec<_>>()
-    }
-}
-
-impl<T> Outputs<(OutputFilter, T)> {
-    pub fn vecs(&self) -> Vec<&T> {
-        [&self.all.1]
-            .into_iter()
-            .chain(self.by_term.vecs())
-            .chain(self.by_up_to_date.vecs())
-            .chain(self.by_from_date.vecs())
-            .chain(self.by_date_range.vecs())
-            .chain(self.by_epoch.vecs())
-            .chain(self.by_size_range.vecs())
-            .chain(self.by_type.vecs())
-            .chain(self.by_up_to_size.vecs())
-            .chain(self.by_from_size.vecs())
-            // .chain(self.by_value.vecs())
-            .collect::<Vec<_>>()
-    }
-}
-
-impl<T> From<Outputs<T>> for Outputs<(OutputFilter, T)> {
-    fn from(value: Outputs<T>) -> Self {
-        Self {
-            all: (OutputFilter::All, value.all),
-            by_term: OutputsByTerm::from(value.by_term),
-            by_up_to_date: OutputsByUpToDate::from(value.by_up_to_date),
-            by_from_date: OutputsByFromDate::from(value.by_from_date),
-            by_date_range: OutputsByDateRange::from(value.by_date_range),
-            by_epoch: OutputsByEpoch::from(value.by_epoch),
-            by_size_range: OutputsBySizeRange::from(value.by_size_range),
-            by_up_to_size: OutputsByUpToSize::from(value.by_up_to_size),
-            by_from_size: OutputsByFromSize::from(value.by_from_size),
-            // Needs whole UTXO set, TODO later
-            // by_value: OutputsByValue<T>,
-            by_type: OutputsBySpendableType::from(value.by_type),
-        }
-    }
-}

crates/brk_state/src/transacted.rs

@@ -1,18 +1,14 @@
-use std::{
-    collections::BTreeMap,
-    mem,
-    ops::{Add, AddAssign},
-};
+use std::ops::{Add, AddAssign};
 
-use brk_core::{OutputType, Sats};
+use brk_core::{GroupedBySizeRange, GroupedByType, OutputType, Sats};
 
-use super::{OutputsByType, SupplyState};
+use super::SupplyState;
 
 #[derive(Default, Debug)]
 pub struct Transacted {
     pub spendable_supply: SupplyState,
-    pub by_type: OutputsByType<SupplyState>,
-    pub by_size_group: BTreeMap<usize, SupplyState>,
+    pub by_type: GroupedByType<SupplyState>,
+    pub by_size_group: GroupedBySizeRange<SupplyState>,
 }
 
 impl Transacted {
@@ -28,55 +24,7 @@ impl Transacted {
 
         self.spendable_supply += &supply;
 
-        let _value = usize::from(value);
-
-        // Need to be in sync with by_size !! but plenty fast (I think)
-        if _value == 0 {
-            *self.by_size_group.entry(0).or_default() += &supply;
-        } else if _value < 10 {
-            *self.by_size_group.entry(1).or_default() += &supply;
-        } else if _value < 100 {
-            *self.by_size_group.entry(10).or_default() += &supply;
-        } else if _value < 1_000 {
-            *self.by_size_group.entry(100).or_default() += &supply;
-        } else if _value < 10_000 {
-            *self.by_size_group.entry(1_000).or_default() += &supply;
-        } else if _value < 100_000 {
-            *self.by_size_group.entry(10_000).or_default() += &supply;
-        } else if _value < 1_000_000 {
-            *self.by_size_group.entry(100_000).or_default() += &supply;
-        } else if _value < 10_000_000 {
-            *self.by_size_group.entry(1_000_000).or_default() += &supply;
-        } else if _value < 1_00_000_000 {
-            *self.by_size_group.entry(10_000_000).or_default() += &supply;
-        } else if _value < 10_00_000_000 {
-            *self.by_size_group.entry(1_00_000_000).or_default() += &supply;
-        } else if _value < 100_00_000_000 {
-            *self.by_size_group.entry(10_00_000_000).or_default() += &supply;
-        } else if _value < 1_000_00_000_000 {
-            *self.by_size_group.entry(100_00_000_000).or_default() += &supply;
-        } else if _value < 10_000_00_000_000 {
-            *self.by_size_group.entry(1_000_00_000_000).or_default() += &supply;
-        } else if _value < 100_000_00_000_000 {
-            *self.by_size_group.entry(10_000_00_000_000).or_default() += &supply;
-        } else {
-            *self.by_size_group.entry(100_000_00_000_000).or_default() += &supply;
-        }
-    }
-
-    fn merge_by_size(
-        first: BTreeMap<usize, SupplyState>,
-        second: BTreeMap<usize, SupplyState>,
-    ) -> BTreeMap<usize, SupplyState> {
-        let (mut source, to_consume) = if first.len() > second.len() {
-            (first, second)
-        } else {
-            (second, first)
-        };
-        to_consume.into_iter().for_each(|(k, v)| {
-            *source.entry(k).or_default() += &v;
-        });
-        source
+        *self.by_size_group.get_mut(value) += &supply;
     }
 }
 
@@ -86,15 +34,14 @@ impl Add for Transacted {
         Self {
             spendable_supply: self.spendable_supply + rhs.spendable_supply,
             by_type: self.by_type + rhs.by_type,
-            by_size_group: Self::merge_by_size(self.by_size_group, rhs.by_size_group),
+            by_size_group: self.by_size_group + rhs.by_size_group,
         }
     }
 }
 
 impl AddAssign for Transacted {
     fn add_assign(&mut self, rhs: Self) {
-        self.by_size_group =
-            Self::merge_by_size(mem::take(&mut self.by_size_group), rhs.by_size_group);
+        self.by_size_group += rhs.by_size_group;
         self.spendable_supply += &rhs.spendable_supply;
         self.by_type += rhs.by_type;
     }