release: v0.0.76

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*"]
 package.description = "The Bitcoin Research Kit is a suite of tools designed to extract, compute and display data stored on a Bitcoin Core node"
 package.license = "MIT"
 package.edition = "2024"
-package.version = "0.0.67"
+package.version = "0.0.76"
 package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 
@@ -13,6 +13,10 @@ lto = "fat"
 codegen-units = 1
 panic = "abort"
 
+[profile.profiling]
+inherits = "release"
+debug = true
+
 [profile.dist]
 inherits = "release"
 
@@ -22,22 +26,22 @@ axum = "0.8.4"
 bincode = { version = "2.0.1", features = ["serde"] }
 bitcoin = { version = "0.32.6", features = ["serde"] }
 bitcoincore-rpc = "0.19.0"
-brk_bundler = { version = "0.0.67", path = "crates/brk_bundler" }
-brk_cli = { version = "0.0.67", path = "crates/brk_cli" }
-brk_computer = { version = "0.0.67", path = "crates/brk_computer" }
-brk_core = { version = "0.0.67", path = "crates/brk_core" }
-brk_exit = { version = "0.0.67", path = "crates/brk_exit" }
-brk_fetcher = { version = "0.0.67", path = "crates/brk_fetcher" }
-brk_indexer = { version = "0.0.67", path = "crates/brk_indexer" }
-brk_interface = { version = "0.0.67", path = "crates/brk_interface" }
-brk_logger = { version = "0.0.67", path = "crates/brk_logger" }
-brk_mcp = { version = "0.0.67", path = "crates/brk_mcp" }
-brk_parser = { version = "0.0.67", path = "crates/brk_parser" }
-brk_rmcp = { version = "0.1.7", features = ["transport-streamable-http-server", "transport-worker"]}
-brk_server = { version = "0.0.67", path = "crates/brk_server" }
-brk_state = { version = "0.0.67", path = "crates/brk_state" }
-brk_store = { version = "0.0.67", path = "crates/brk_store" }
-brk_vec = { version = "0.0.67", path = "crates/brk_vec" }
+brk_bundler = { version = "0.0.76", path = "crates/brk_bundler" }
+brk_cli = { version = "0.0.76", path = "crates/brk_cli" }
+brk_computer = { version = "0.0.76", path = "crates/brk_computer" }
+brk_core = { version = "0.0.76", path = "crates/brk_core" }
+brk_exit = { version = "0.0.76", path = "crates/brk_exit" }
+brk_fetcher = { version = "0.0.76", path = "crates/brk_fetcher" }
+brk_indexer = { version = "0.0.76", path = "crates/brk_indexer" }
+brk_interface = { version = "0.0.76", path = "crates/brk_interface" }
+brk_logger = { version = "0.0.76", path = "crates/brk_logger" }
+brk_mcp = { version = "0.0.76", path = "crates/brk_mcp" }
+brk_parser = { version = "0.0.76", path = "crates/brk_parser" }
+brk_rmcp = { version = "0.2.1", features = ["transport-streamable-http-server", "transport-worker"]}
+# brk_rmcp = { path = "../rust-sdk/crates/rmcp", features = ["transport-streamable-http-server", "transport-worker"]}
+brk_server = { version = "0.0.76", path = "crates/brk_server" }
+brk_store = { version = "0.0.76", path = "crates/brk_store" }
+brk_vec = { version = "0.0.76", path = "crates/brk_vec" }
 byteview = "=0.6.1"
 clap = { version = "4.5.40", features = ["string"] }
 clap_derive = "4.5.40"
@@ -46,15 +50,15 @@ derive_deref = "1.1.1"
 fjall = "2.11.1"
 jiff = "0.2.15"
 log = { version = "0.4.27" }
-minreq = { version = "2.13.4", features = ["https", "serde_json"] }
+minreq = { version = "2.14.0", features = ["https", "serde_json"] }
 rayon = "1.10.0"
-schemars = "1.0.0"
+schemars = "1.0.4"
 serde = { version = "1.0.219" }
 serde_bytes = "0.11.17"
 serde_derive = "1.0.219"
 serde_json = { version = "1.0.140", features = ["float_roundtrip"] }
 tabled = "0.20.0"
-tokio = { version = "1.45.1", features = ["rt-multi-thread"] }
+tokio = { version = "1.46.1", features = ["rt-multi-thread"] }
 zerocopy = { version = "0.8.26" }
 zerocopy-derive = "0.8.26"
 

README.md

@@ -42,7 +42,7 @@ The toolkit can be used in various ways to accommodate as many needs as possible
   It has a wide range of functionalities including charts, tables and simulations which you can visit for free and without the need for an account. \
   Also available at: [kibo.money](https://kibo.money) // [satonomics.xyz](https://satonomics.xyz)
 - **[API](https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#brk-server)** \
-  Researchers and developers are free to use BRK's public API with ![Datasets variant count](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fbitcoinresearchkit.org%2Fapi%2Fvecs%2Fvariant-count&query=%24&style=flat&label=%20&color=white) dataset variants at their disposal. \
+  Researchers and developers are free to use BRK's public API with ![Datasets variant count](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fbitcoinresearchkit.org%2Fapi%2Fvecs%2Fvec-count&query=%24&style=flat&label=%20&color=white) dataset variants at their disposal. \
   Just like the website, it's entirely free, with no authentication or rate-limiting.
 - **[AI](https://github.com/bitcoinresearchkit/brk/blob/main/crates/brk_mcp/README.md#brk-mcp)** \
   LLMs have to possibility to connect to BRK's backend through a [MCP](https://modelcontextprotocol.io/introduction). \
@@ -73,7 +73,6 @@ In contrast, existing alternatives tend to be either [very costly](https://studi
 - [`brk_parser`](https://crates.io/crates/brk_parser): A very fast Bitcoin Core block parser and iterator built on top of bitcoin-rust
 - [`brk_interface`](https://crates.io/crates/brk_interface): An interface to BRK's engine
 - [`brk_server`](https://crates.io/crates/brk_server): A server that serves Bitcoin data and swappable front-ends, built on top of `brk_indexer`, `brk_fetcher` and `brk_computer`
-- [`brk_state`](https://crates.io/crates/brk_state): Various states used mainly by the computer
 - [`brk_store`](https://crates.io/crates/brk_store): A thin wrapper around [`fjall`](https://crates.io/crates/fjall)
 - [`brk_vec`](https://crates.io/crates/brk_vec): A push-only, truncable, compressable, saveable Vec
 - [`brk_bundler`](https://crates.io/crates/brk_bundler): A thin wrapper around [`rolldown`](https://rolldown.rs/)

TODO.md

@@ -0,0 +1,92 @@
+# TODO
+
+- __crates__
+  - _cli_
+    - check disk space on first launch
+    - add custom path support for config.toml
+    - maybe add bitcoind download and launch support
+      - via: https://github.com/rust-bitcoin/corepc/blob/master/node
+    - test read/write speed, add warning if too low (<2gb/s)
+    - pull latest version and notify is out of date
+  - _computer_
+    - **add rollback of states (in stateful)**
+    - add support for per index computation
+    - fix feerate which is always ZERO due to coinbase transaction
+    - before computing multiple sources check their length, panic if not equal
+    - add oracle price dataset (https://utxo.live/oracle/UTXOracle.py)
+    - add address counts relative to all datasets
+    - make decade, quarter, year datasets `computed` instead of `eager`
+    - add 6 months (semester) interval datasets to builder
+    - add revived/sent supply datasets
+    - add `in-sats` version of all price datasets (average and co)
+    - add `p2pk` group (sum of `p2pk33` and `p2pk65`)
+    - add more date ranges (3-6 months and more)
+    - add puell multiple dataset
+    - add pi cycle dataset
+    - add ema of price
+    - add 7d and 30d ema to sell side risk ratio and sopr
+    - add all possible charts from:
+      - https://mainnet.observer
+      - https://glassnode.com
+      - https://checkonchain.com
+      - https://researchbitcoin.net/exciting-update-coming-to-the-bitcoin-lab/
+      - https://mempool.space/research
+  - _indexer_
+    - parse only the needed block number
+      - maybe using https://developer.bitcoin.org/reference/rpc/getblockhash.html
+  - _interface_
+    - create pagination enum
+      - from to
+      - from option<count>
+      - to option<count>
+      - page + option<per page> default 1000 max 1000
+    - from/to/count params don’t cap all combinations
+      - example: from -10,000 count 10, won’t work if underlying vec isn’t 10k or more long
+  - _parser_
+    - save `vec` file instead of `json`
+    - support lock file, process in read only if already opened in write mode
+    - if less than X (10 maybe ?) get block using rpc instead of parsing the block files
+  - _server_
+    - api
+      - add extensions support (.json .csv …)
+      - if format instead of extension then don't download file
+  - _vec_
+    - add native lock file support (once it's available in stable rust)
+    - improve compressed mode (slow reads)
+    - add ema support
+- __docs__
+  - _README_
+    - add a comparison table with alternatives
+    - add contribution section where help is needed
+      - documentation/mcp/datasets/different front ends
+    - add faq
+- __websites__
+  - _default_
+    - explorer
+      - blocks
+      - transactions
+      - addresses
+      - miners
+      - maybe xpubs
+    - charts
+      - improve some names and colors
+      - remove `sum` series when it's a duplicate of the `base` (in subsidy for example)
+      - selected unit sometimes changes when going back end forth
+      - add support for custom charts
+      - price scale format depends on unit, hide digits for sats for example (if/when possible)
+    - table
+      - pagination
+      - exports (.json, .csv,…)
+    - search
+      - datasets add legend, and keywords ?
+      - height/address/txid
+    - api
+      - add api page with interactivity
+    - global
+      - **fix navigation/history**
+      - move share button to footer ?
+      - Use `ichart.createPane()` in wrapper
+      - improve behavior when local storage is unavailable
+        - by having a global state
+- __global__
+  - check `TODO`s in codebase

crates/brk/.gitignore

@@ -0,0 +1,2 @@
+profile.json.gz
+flamegraph.svg

crates/brk/Cargo.toml

@@ -21,7 +21,6 @@ full = [
     "parser",
     "interface",
     "server",
-    "state",
     "store",
     "vec",
 ]
@@ -36,7 +35,6 @@ mcp = ["brk_mcp"]
 parser = ["brk_parser"]
 interface = ["brk_interface"]
 server = ["brk_server"]
-state = ["brk_state"]
 store = ["brk_store"]
 vec = ["brk_vec"]
 
@@ -53,7 +51,6 @@ brk_mcp = { workspace = true, optional = true }
 brk_parser = { workspace = true, optional = true }
 brk_interface = { workspace = true, optional = true }
 brk_server = { workspace = true, optional = true }
-brk_state = { workspace = true, optional = true }
 brk_store = { workspace = true, optional = true }
 brk_vec = { workspace = true, optional = true }
 

crates/brk/flamegraph.sh

@@ -0,0 +1,2 @@
+cargo build --profile profiling
+flamegraph -- ../../target/profiling/brk

crates/brk/samply.sh

@@ -0,0 +1,2 @@
+cargo build --profile profiling
+samply record ../../target/profiling/brk

crates/brk/src/lib.rs

@@ -47,10 +47,6 @@ pub use brk_interface as interface;
 #[doc(inline)]
 pub use brk_server as server;
 
-#[cfg(feature = "state")]
-#[doc(inline)]
-pub use brk_state as state;
-
 #[cfg(feature = "store")]
 #[doc(inline)]
 pub use brk_store as store;

crates/brk_bundler/Cargo.toml

@@ -9,7 +9,8 @@ repository.workspace = true
 
 [dependencies]
 log = { workspace = true }
-notify = "8.0.0"
-brk_rolldown = "0.0.1"
+notify = "8.1.0"
+brk_rolldown = "0.1.1"
+# brk_rolldown = { path = "../../../rolldown/crates/rolldown"}
 sugar_path = "1.2.0"
 tokio = { workspace = true }

crates/brk_bundler/src/lib.rs

@@ -81,7 +81,7 @@ pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> i
         let mut entry_watcher = notify::recommended_watcher(
             move |res: Result<notify::Event, notify::Error>| match res {
                 Ok(_) => write_index_clone(),
-                Err(e) => error!("watch error: {:?}", e),
+                Err(e) => error!("watch error: {e:?}"),
             },
         )
         .unwrap();
@@ -112,7 +112,7 @@ pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> i
                         let _ = fs::copy(&source_path, &dist_path);
                     }
                 }),
-                Err(e) => error!("watch error: {:?}", e),
+                Err(e) => error!("watch error: {e:?}"),
             },
         )
         .unwrap();

crates/brk_cli/Cargo.toml

@@ -24,7 +24,7 @@ color-eyre = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true }
 tokio = { workspace = true }
-toml = "0.8.23"
+toml = "0.9.0"
 
 [[bin]]
 name = "brk"

crates/brk_cli/src/config.rs

@@ -16,6 +16,7 @@ use serde::{Deserialize, Serialize};
 use crate::services::Services;
 
 #[derive(Parser, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
+#[command(version, about)]
 pub struct Config {
     /// Bitcoin main directory path, defaults: ~/.bitcoin, ~/Library/Application\ Support/Bitcoin, saved
     #[serde(default, deserialize_with = "default_on_error")]
@@ -87,7 +88,7 @@ pub struct Config {
     #[arg(long, value_name = "SECONDS")]
     delay: Option<u64>,
 
-    /// Activate the Model Context Protocol (MCP) endpoint to give LLMs access to BRK (experimental), default: false, saved
+    /// Activate the Model Context Protocol (MCP) endpoint to give LLMs access to BRK (experimental), default: true, saved
     #[serde(default, deserialize_with = "default_on_error")]
     #[arg(long, value_name = "BOOL")]
     mcp: Option<bool>,
@@ -366,7 +367,7 @@ impl Config {
     }
 
     pub fn mcp(&self) -> bool {
-        self.mcp.is_some_and(|b| b)
+        self.mcp.is_none_or(|b| b)
     }
 
     pub fn watch(&self) -> bool {

crates/brk_computer/Cargo.toml

@@ -8,6 +8,7 @@ homepage.workspace = true
 repository.workspace = true
 
 [dependencies]
+bincode = { workspace = true }
 bitcoin = { workspace = true }
 bitcoincore-rpc = { workspace = true }
 brk_core = { workspace = true }
@@ -16,10 +17,18 @@ brk_fetcher = { workspace = true }
 brk_indexer = { workspace = true }
 brk_logger = { workspace = true }
 brk_parser = { workspace = true }
-brk_state = { workspace = true }
+brk_store = { workspace = true }
 brk_vec = { workspace = true }
 color-eyre = { workspace = true }
+derive_deref = { workspace = true }
+either = "1.15.0"
 fjall = { workspace = true }
 jiff = { workspace = true }
 log = { workspace = true }
 rayon = { workspace = true }
+serde = { workspace = true }
+zerocopy = { workspace = true }
+zerocopy-derive = { workspace = true }
+
+[package.metadata.cargo-machete]
+ignored = ["zerocopy"]

crates/brk_computer/src/lib.rs

@@ -10,12 +10,14 @@ use brk_exit::Exit;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
 use brk_vec::{Computation, Format};
+use log::info;
 
+mod states;
 mod stores;
 mod utils;
 mod vecs;
 
-use log::info;
+use states::*;
 use stores::Stores;
 use vecs::Vecs;
 
@@ -66,7 +68,12 @@ impl Computer {
         exit: &Exit,
     ) -> color_eyre::Result<()> {
         info!("Computing...");
-        self.vecs
-            .compute(indexer, starting_indexes, self.fetcher.as_mut(), exit)
+        self.vecs.compute(
+            indexer,
+            starting_indexes,
+            self.fetcher.as_mut(),
+            exit,
+            &mut self.stores,
+        )
     }
 }

crates/brk_computer/src/states/cohorts/address.rs

@@ -0,0 +1,120 @@
+use std::path::Path;
+
+use brk_core::{AddressData, Dollars, Height, Result, Sats};
+
+use crate::SupplyState;
+
+use super::CohortState;
+
+#[derive(Clone)]
+pub struct AddressCohortState {
+    pub address_count: usize,
+    pub inner: CohortState,
+}
+
+impl AddressCohortState {
+    pub 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)?,
+        })
+    }
+
+    pub fn height(&self) -> Option<Height> {
+        self.inner.height()
+    }
+
+    pub fn reset_price_to_amount(&mut self) -> Result<()> {
+        self.inner.reset_price_to_amount()
+    }
+
+    pub fn reset_single_iteration_values(&mut self) {
+        self.inner.reset_single_iteration_values();
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn send(
+        &mut self,
+        addressdata: &mut AddressData,
+        value: Sats,
+        current_price: Option<Dollars>,
+        prev_price: Option<Dollars>,
+        blocks_old: usize,
+        days_old: f64,
+        older_than_hour: bool,
+    ) -> Result<()> {
+        let compute_price = current_price.is_some();
+
+        let prev_realized_price = compute_price.then(|| addressdata.realized_price());
+        let prev_supply_state = SupplyState {
+            utxos: addressdata.outputs_len as usize,
+            value: addressdata.amount(),
+        };
+
+        addressdata.send(value, prev_price)?;
+
+        let supply_state = SupplyState {
+            utxos: addressdata.outputs_len as usize,
+            value: addressdata.amount(),
+        };
+
+        self.inner.send_(
+            &SupplyState { utxos: 1, value },
+            current_price,
+            prev_price,
+            blocks_old,
+            days_old,
+            older_than_hour,
+            compute_price.then(|| (addressdata.realized_price(), &supply_state)),
+            prev_realized_price.map(|prev_price| (prev_price, &prev_supply_state)),
+        );
+
+        Ok(())
+    }
+
+    pub fn receive(&mut self, address_data: &mut AddressData, value: Sats, price: Option<Dollars>) {
+        let compute_price = price.is_some();
+
+        let prev_realized_price = compute_price.then(|| address_data.realized_price());
+        let prev_supply_state = SupplyState {
+            utxos: address_data.outputs_len as usize,
+            value: address_data.amount(),
+        };
+
+        address_data.receive(value, price);
+
+        let supply_state = SupplyState {
+            utxos: address_data.outputs_len as usize,
+            value: address_data.amount(),
+        };
+
+        self.inner.receive_(
+            &SupplyState { utxos: 1, value },
+            price,
+            compute_price.then(|| (address_data.realized_price(), &supply_state)),
+            prev_realized_price.map(|prev_price| (prev_price, &prev_supply_state)),
+        );
+    }
+
+    pub fn add(&mut self, addressdata: &AddressData) {
+        self.address_count += 1;
+        self.inner.increment_(
+            &addressdata.into(),
+            addressdata.realized_cap,
+            addressdata.realized_price(),
+        );
+    }
+
+    pub fn subtract(&mut self, addressdata: &AddressData) {
+        self.address_count = self.address_count.checked_sub(1).unwrap();
+        self.inner.decrement_(
+            &addressdata.into(),
+            addressdata.realized_cap,
+            addressdata.realized_price(),
+        );
+    }
+
+    pub fn commit(&mut self, height: Height) -> Result<()> {
+        self.inner.commit(height)
+    }
+}

crates/brk_computer/src/states/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::{PriceToAmount, RealizedState, SupplyState, UnrealizedState};
 
 #[derive(Clone)]
 pub struct CohortState {
@@ -12,7 +10,8 @@ pub struct CohortState {
     pub realized: Option<RealizedState>,
     pub satblocks_destroyed: Sats,
     pub satdays_destroyed: Sats,
-    pub price_to_amount: PriceToAmount,
+
+    price_to_amount: PriceToAmount,
 }
 
 impl CohortState {
@@ -26,6 +25,22 @@ impl CohortState {
         })
     }
 
+    pub fn height(&self) -> Option<Height> {
+        self.price_to_amount.height()
+    }
+
+    pub fn reset_price_to_amount(&mut self) -> Result<()> {
+        self.price_to_amount.reset()
+    }
+
+    pub fn price_to_amount_first_key_value(&self) -> Option<(&Dollars, &Sats)> {
+        self.price_to_amount.first_key_value()
+    }
+
+    pub fn price_to_amount_last_key_value(&self) -> Option<(&Dollars, &Sats)> {
+        self.price_to_amount.last_key_value()
+    }
+
     pub fn reset_single_iteration_values(&mut self) {
         self.satdays_destroyed = Sats::ZERO;
         self.satblocks_destroyed = Sats::ZERO;
@@ -41,7 +56,23 @@ impl CohortState {
             if let Some(realized) = self.realized.as_mut() {
                 let price = price.unwrap();
                 realized.increment(supply_state, price);
-                *self.price_to_amount.entry(price).or_default() += supply_state.value;
+                self.price_to_amount.increment(price, supply_state);
+            }
+        }
+    }
+
+    pub fn increment_(
+        &mut self,
+        supply_state: &SupplyState,
+        realized_cap: Dollars,
+        realized_price: Dollars,
+    ) {
+        self.supply += supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            if let Some(realized) = self.realized.as_mut() {
+                realized.increment_(realized_cap);
+                self.price_to_amount.increment(realized_price, supply_state);
             }
         }
     }
@@ -53,27 +84,60 @@ impl CohortState {
             if let Some(realized) = self.realized.as_mut() {
                 let price = price.unwrap();
                 realized.decrement(supply_state, price);
-                self.decrement_price_to_amount(supply_state, price);
+                self.price_to_amount.decrement(price, supply_state);
             }
         }
     }
 
-    fn decrement_price_to_amount(&mut self, supply_state: &SupplyState, price: Dollars) {
-        let amount = self.price_to_amount.get_mut(&price).unwrap();
-        *amount -= supply_state.value;
-        if *amount == Sats::ZERO {
-            self.price_to_amount.remove(&price);
+    pub fn decrement_(
+        &mut self,
+        supply_state: &SupplyState,
+        realized_cap: Dollars,
+        realized_price: Dollars,
+    ) {
+        self.supply -= supply_state;
+
+        if supply_state.value > Sats::ZERO {
+            if let Some(realized) = self.realized.as_mut() {
+                realized.decrement_(realized_cap);
+                self.price_to_amount.decrement(realized_price, supply_state);
+            }
         }
     }
 
     pub fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.receive_(
+            supply_state,
+            price,
+            price.map(|price| (price, supply_state)),
+            None,
+        );
+    }
+
+    pub fn receive_(
+        &mut self,
+        supply_state: &SupplyState,
+        price: Option<Dollars>,
+        price_to_amount_increment: Option<(Dollars, &SupplyState)>,
+        price_to_amount_decrement: Option<(Dollars, &SupplyState)>,
+    ) {
         self.supply += supply_state;
 
         if supply_state.value > Sats::ZERO {
             if let Some(realized) = self.realized.as_mut() {
                 let price = price.unwrap();
                 realized.receive(supply_state, price);
-                *self.price_to_amount.entry(price).or_default() += supply_state.value;
+
+                if let Some((price, supply)) = price_to_amount_increment
+                    && supply.value.is_not_zero()
+                {
+                    self.price_to_amount.increment(price, supply);
+                }
+                if let Some((price, supply)) = price_to_amount_decrement
+                    && supply.value.is_not_zero()
+                {
+                    self.price_to_amount.decrement(price, supply);
+                }
             }
         }
     }
@@ -87,6 +151,34 @@ impl CohortState {
         days_old: f64,
         older_than_hour: bool,
     ) {
+        self.send_(
+            supply_state,
+            current_price,
+            prev_price,
+            blocks_old,
+            days_old,
+            older_than_hour,
+            None,
+            prev_price.map(|prev_price| (prev_price, supply_state)),
+        );
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub 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,
+        price_to_amount_increment: Option<(Dollars, &SupplyState)>,
+        price_to_amount_decrement: Option<(Dollars, &SupplyState)>,
+    ) {
+        if supply_state.utxos == 0 {
+            return;
+        }
+
         self.supply -= supply_state;
 
         if supply_state.value > Sats::ZERO {
@@ -99,7 +191,16 @@ impl CohortState {
                 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((price, supply)) = price_to_amount_increment
+                    && supply.value.is_not_zero()
+                {
+                    self.price_to_amount.increment(price, supply);
+                }
+                if let Some((price, supply)) = price_to_amount_decrement
+                    && supply.value.is_not_zero()
+                {
+                    self.price_to_amount.decrement(price, supply);
+                }
             }
         }
     }

crates/brk_computer/src/states/cohorts/mod.rs

@@ -0,0 +1,7 @@
+mod address;
+mod common;
+mod utxo;
+
+pub use address::*;
+pub use common::*;
+pub use utxo::*;

crates/brk_computer/src/states/cohorts/utxo.rs

@@ -0,0 +1,27 @@
+use std::path::Path;
+
+use brk_core::{Height, Result};
+use derive_deref::{Deref, DerefMut};
+
+use super::CohortState;
+
+#[derive(Clone, Deref, DerefMut)]
+pub struct UTXOCohortState(CohortState);
+
+impl UTXOCohortState {
+    pub fn default_and_import(path: &Path, name: &str, compute_dollars: bool) -> Result<Self> {
+        Ok(Self(CohortState::default_and_import(
+            path,
+            name,
+            compute_dollars,
+        )?))
+    }
+
+    pub fn height(&self) -> Option<Height> {
+        self.0.height()
+    }
+
+    pub fn reset_price_to_amount(&mut self) -> Result<()> {
+        self.0.reset_price_to_amount()
+    }
+}

crates/brk_computer/src/states/mod.rs

@@ -0,0 +1,15 @@
+mod block;
+mod cohorts;
+mod price_to_amount;
+mod realized;
+mod supply;
+mod transacted;
+mod unrealized;
+
+pub use block::*;
+pub use cohorts::*;
+pub use price_to_amount::*;
+pub use realized::*;
+pub use supply::*;
+pub use transacted::*;
+pub use unrealized::*;

crates/brk_computer/src/states/price_to_amount.rs

@@ -2,7 +2,6 @@ use std::{
     collections::BTreeMap,
     fs::{self, File},
     io::{BufReader, BufWriter},
-    ops::{Deref, DerefMut},
     path::{Path, PathBuf},
 };
 
@@ -11,6 +10,8 @@ use brk_core::{Dollars, Height, Result, Sats};
 use derive_deref::{Deref, DerefMut};
 use serde::{Deserialize, Serialize};
 
+use crate::states::SupplyState;
+
 #[derive(Clone, Debug)]
 pub struct PriceToAmount {
     pathbuf: PathBuf,
@@ -46,8 +47,36 @@ impl PriceToAmount {
         })
     }
 
+    pub fn iter(&self) -> impl Iterator<Item = (&Dollars, &Sats)> {
+        self.state.iter()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.state.is_empty()
+    }
+
+    pub fn first_key_value(&self) -> Option<(&Dollars, &Sats)> {
+        self.state.first_key_value()
+    }
+
+    pub fn last_key_value(&self) -> Option<(&Dollars, &Sats)> {
+        self.state.last_key_value()
+    }
+
+    pub fn increment(&mut self, price: Dollars, supply_state: &SupplyState) {
+        *self.state.entry(price).or_default() += supply_state.value;
+    }
+
+    pub fn decrement(&mut self, price: Dollars, supply_state: &SupplyState) {
+        let amount = self.state.get_mut(&price).unwrap();
+        *amount -= supply_state.value;
+        if *amount == Sats::ZERO {
+            self.state.remove(&price);
+        }
+    }
+
     pub fn reset(&mut self) -> Result<()> {
-        self.clear();
+        self.state.clear();
         self.height = None;
         fs::remove_dir_all(&self.pathbuf)?;
         fs::create_dir_all(&self.pathbuf)?;
@@ -89,16 +118,3 @@ impl PriceToAmount {
         path.join("height")
     }
 }
-
-impl Deref for PriceToAmount {
-    type Target = BTreeMap<Dollars, Sats>;
-    fn deref(&self) -> &Self::Target {
-        &self.state
-    }
-}
-
-impl DerefMut for PriceToAmount {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.state
-    }
-}

crates/brk_computer/src/states/realized.rs

@@ -42,6 +42,10 @@ impl RealizedState {
             return;
         }
 
+        self.increment_(price * supply_state.value)
+    }
+
+    pub fn increment_(&mut self, realized_cap: Dollars) {
         if self.cap == Dollars::NAN {
             self.cap = Dollars::ZERO;
             self.profit = Dollars::ZERO;
@@ -52,13 +56,15 @@ impl RealizedState {
             self.adj_value_destroyed = Dollars::ZERO;
         }
 
-        let value = price * supply_state.value;
-        self.cap += value;
+        self.cap += realized_cap;
     }
 
     pub fn decrement(&mut self, supply_state: &SupplyState, price: Dollars) {
-        let value = price * supply_state.value;
-        self.cap = self.cap.checked_sub(value).unwrap();
+        self.decrement_(price * supply_state.value);
+    }
+
+    pub fn decrement_(&mut self, realized_cap: Dollars) {
+        self.cap = self.cap.checked_sub(realized_cap).unwrap();
     }
 
     pub fn receive(&mut self, supply_state: &SupplyState, current_price: Dollars) {

crates/brk_computer/src/states/supply.rs

@@ -1,6 +1,6 @@
 use std::ops::{Add, AddAssign, SubAssign};
 
-use brk_core::{CheckedSub, Sats};
+use brk_core::{AddressData, CheckedSub, Sats};
 use serde::Serialize;
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
@@ -39,3 +39,12 @@ impl SubAssign<&SupplyState> for SupplyState {
         self.value = self.value.checked_sub(rhs.value).unwrap();
     }
 }
+
+impl From<&AddressData> for SupplyState {
+    fn from(value: &AddressData) -> Self {
+        Self {
+            utxos: value.outputs_len as usize,
+            value: value.amount(),
+        }
+    }
+}

crates/brk_computer/src/states/transacted.rs

@@ -0,0 +1,48 @@
+use std::ops::{Add, AddAssign};
+
+use brk_core::{ByAmountRange, GroupedByType, OutputType, Sats};
+
+use super::SupplyState;
+
+#[derive(Default, Debug)]
+pub struct Transacted {
+    pub spendable_supply: SupplyState,
+    pub by_type: GroupedByType<SupplyState>,
+    pub by_size_group: ByAmountRange<SupplyState>,
+}
+
+impl Transacted {
+    #[allow(clippy::inconsistent_digit_grouping)]
+    pub fn iterate(&mut self, value: Sats, _type: OutputType) {
+        let supply = SupplyState { utxos: 1, value };
+
+        *self.by_type.get_mut(_type) += &supply;
+
+        if _type.is_unspendable() {
+            return;
+        }
+
+        self.spendable_supply += &supply;
+
+        *self.by_size_group.get_mut(value) += &supply;
+    }
+}
+
+impl Add for Transacted {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            spendable_supply: self.spendable_supply + rhs.spendable_supply,
+            by_type: self.by_type + rhs.by_type,
+            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 += rhs.by_size_group;
+        self.spendable_supply += &rhs.spendable_supply;
+        self.by_type += rhs.by_type;
+    }
+}

crates/brk_computer/src/stores.rs

@@ -1,34 +1,647 @@
-use std::path::Path;
+use std::{path::Path, thread};
 
-use brk_core::Version;
-use fjall::TransactionalKeyspace;
+use brk_core::{
+    AddressData, ByAddressType, EmptyAddressData, Height, OutputType, P2AAddressIndex,
+    P2PK33AddressIndex, P2PK65AddressIndex, P2PKHAddressIndex, P2SHAddressIndex, P2TRAddressIndex,
+    P2WPKHAddressIndex, P2WSHAddressIndex, Result, TypeIndex, Version,
+};
+use brk_store::{AnyStore, Store};
+use fjall::{PersistMode, TransactionalKeyspace};
+use log::info;
 
-const _VERSION: Version = Version::ZERO;
+use crate::vecs::stateful::{AddressTypeToTypeIndexTree, WithAddressDataSource};
+
+const VERSION: Version = Version::ZERO;
 
 #[derive(Clone)]
 pub struct Stores {
-    // pub address_to_utxos_received: Store<AddressIndexOutputIndex, Unit>,
-    // pub address_to_utxos_spent: Store<AddressIndexOutputIndex, Unit>,
+    keyspace: TransactionalKeyspace,
+
+    pub p2aaddressindex_to_addressdata: Store<P2AAddressIndex, AddressData>,
+    pub p2aaddressindex_to_emptyaddressdata: Store<P2AAddressIndex, EmptyAddressData>,
+    pub p2pk33addressindex_to_addressdata: Store<P2PK33AddressIndex, AddressData>,
+    pub p2pk33addressindex_to_emptyaddressdata: Store<P2PK33AddressIndex, EmptyAddressData>,
+    pub p2pk65addressindex_to_addressdata: Store<P2PK65AddressIndex, AddressData>,
+    pub p2pk65addressindex_to_emptyaddressdata: Store<P2PK65AddressIndex, EmptyAddressData>,
+    pub p2pkhaddressindex_to_addressdata: Store<P2PKHAddressIndex, AddressData>,
+    pub p2pkhaddressindex_to_emptyaddressdata: Store<P2PKHAddressIndex, EmptyAddressData>,
+    pub p2shaddressindex_to_addressdata: Store<P2SHAddressIndex, AddressData>,
+    pub p2shaddressindex_to_emptyaddressdata: Store<P2SHAddressIndex, EmptyAddressData>,
+    pub p2traddressindex_to_addressdata: Store<P2TRAddressIndex, AddressData>,
+    pub p2traddressindex_to_emptyaddressdata: Store<P2TRAddressIndex, EmptyAddressData>,
+    pub p2wpkhaddressindex_to_addressdata: Store<P2WPKHAddressIndex, AddressData>,
+    pub p2wpkhaddressindex_to_emptyaddressdata: Store<P2WPKHAddressIndex, EmptyAddressData>,
+    pub p2wshaddressindex_to_addressdata: Store<P2WSHAddressIndex, AddressData>,
+    pub p2wshaddressindex_to_emptyaddressdata: Store<P2WSHAddressIndex, EmptyAddressData>,
 }
 
 impl Stores {
-    pub fn import(_: &Path, _: Version, _: &TransactionalKeyspace) -> color_eyre::Result<Self> {
-        // let address_to_utxos_received = Store::import(
-        //     keyspace.clone(),
-        //     path,
-        //     "address_to_utxos_received",
-        //     version + VERSION + Version::ZERO,
-        // )?;
-        // let address_to_utxos_spent = Store::import(
-        //     keyspace.clone(),
-        //     path,
-        //     "address_to_utxos_spent",
-        //     version + VERSION + Version::ZERO,
-        // )?;
+    pub fn import(
+        path: &Path,
+        version: Version,
+        keyspace: &TransactionalKeyspace,
+    ) -> color_eyre::Result<Self> {
+        let (
+            (p2aaddressindex_to_addressdata, p2aaddressindex_to_emptyaddressdata),
+            (p2pk33addressindex_to_addressdata, p2pk33addressindex_to_emptyaddressdata),
+            (p2pk65addressindex_to_addressdata, p2pk65addressindex_to_emptyaddressdata),
+            (p2pkhaddressindex_to_addressdata, p2pkhaddressindex_to_emptyaddressdata),
+            (p2shaddressindex_to_addressdata, p2shaddressindex_to_emptyaddressdata),
+            (p2traddressindex_to_addressdata, p2traddressindex_to_emptyaddressdata),
+            (p2wpkhaddressindex_to_addressdata, p2wpkhaddressindex_to_emptyaddressdata),
+            (p2wshaddressindex_to_addressdata, p2wshaddressindex_to_emptyaddressdata),
+        ) = thread::scope(|scope| {
+            let p2a = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2aaddressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2aaddressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            let p2pk33 = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2pk33addressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2pk33addressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            let p2pk65 = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2pk65addressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2pk65addressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            let p2pkh = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2pkhaddressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2pkhaddressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            let p2sh = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2shaddressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2shaddressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            let p2tr = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2traddressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2traddressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            let p2wpkh = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2wpkhaddressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2wpkhaddressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            let p2wsh = scope.spawn(|| {
+                (
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2wshaddressindex_to_addressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                    Store::import(
+                        keyspace,
+                        path,
+                        "p2wshaddressindex_to_emptyaddressdata",
+                        version + VERSION + Version::ZERO,
+                        None,
+                    )
+                    .unwrap(),
+                )
+            });
+
+            (
+                p2a.join().unwrap(),
+                p2pk33.join().unwrap(),
+                p2pk65.join().unwrap(),
+                p2pkh.join().unwrap(),
+                p2sh.join().unwrap(),
+                p2tr.join().unwrap(),
+                p2wpkh.join().unwrap(),
+                p2wsh.join().unwrap(),
+            )
+        });
 
         Ok(Self {
-            // address_to_utxos_received,
-            // address_to_utxos_spent,
+            keyspace: keyspace.clone(),
+
+            p2aaddressindex_to_addressdata,
+            p2aaddressindex_to_emptyaddressdata,
+
+            p2pk33addressindex_to_addressdata,
+            p2pk33addressindex_to_emptyaddressdata,
+
+            p2pk65addressindex_to_addressdata,
+            p2pk65addressindex_to_emptyaddressdata,
+
+            p2pkhaddressindex_to_addressdata,
+            p2pkhaddressindex_to_emptyaddressdata,
+
+            p2shaddressindex_to_addressdata,
+            p2shaddressindex_to_emptyaddressdata,
+
+            p2traddressindex_to_addressdata,
+            p2traddressindex_to_emptyaddressdata,
+
+            p2wpkhaddressindex_to_addressdata,
+            p2wpkhaddressindex_to_emptyaddressdata,
+
+            p2wshaddressindex_to_addressdata,
+            p2wshaddressindex_to_emptyaddressdata,
         })
     }
+
+    pub fn starting_height(&self) -> Height {
+        self.as_slice()
+            .into_iter()
+            .map(|store| store.height().map(Height::incremented).unwrap_or_default())
+            .min()
+            .unwrap()
+    }
+
+    pub fn reset(&mut self) -> Result<()> {
+        info!("Resetting stores...");
+        info!("> If it gets stuck here, stop the program and start it again");
+
+        self.as_mut_slice()
+            .into_iter()
+            .try_for_each(|store| store.reset())?;
+
+        self.keyspace
+            .persist(PersistMode::SyncAll)
+            .map_err(|e| e.into())
+    }
+
+    pub fn get_addressdata(
+        &self,
+        address_type: OutputType,
+        type_index: TypeIndex,
+    ) -> Result<Option<AddressData>> {
+        Ok(match address_type {
+            OutputType::P2A => self
+                .p2aaddressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2PK33 => self
+                .p2pk33addressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2PK65 => self
+                .p2pk65addressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2PKH => self
+                .p2pkhaddressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2SH => self
+                .p2shaddressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2TR => self
+                .p2traddressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2WPKH => self
+                .p2wpkhaddressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2WSH => self
+                .p2wshaddressindex_to_addressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            _ => unreachable!(),
+        })
+    }
+
+    pub fn get_emptyaddressdata(
+        &self,
+        address_type: OutputType,
+        type_index: TypeIndex,
+    ) -> Result<Option<EmptyAddressData>> {
+        Ok(match address_type {
+            OutputType::P2A => self
+                .p2aaddressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2PK33 => self
+                .p2pk33addressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2PK65 => self
+                .p2pk65addressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2PKH => self
+                .p2pkhaddressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2SH => self
+                .p2shaddressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2TR => self
+                .p2traddressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2WPKH => self
+                .p2wpkhaddressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            OutputType::P2WSH => self
+                .p2wshaddressindex_to_emptyaddressdata
+                .get(&type_index.into())?
+                .map(|c| c.into_owned()),
+            _ => unreachable!(),
+        })
+    }
+
+    pub fn commit(
+        &mut self,
+        height: Height,
+        addresstype_to_typeindex_to_addressdata: AddressTypeToTypeIndexTree<
+            WithAddressDataSource<AddressData>,
+        >,
+        addresstype_to_typeindex_to_emptyaddressdata: AddressTypeToTypeIndexTree<
+            WithAddressDataSource<EmptyAddressData>,
+        >,
+    ) -> Result<()> {
+        let ByAddressType {
+            p2pk65,
+            p2pk33,
+            p2pkh,
+            p2sh,
+            p2wpkh,
+            p2wsh,
+            p2tr,
+            p2a,
+        } = addresstype_to_typeindex_to_addressdata.unwrap();
+
+        let ByAddressType {
+            p2pk65: empty_p2pk65,
+            p2pk33: empty_p2pk33,
+            p2pkh: empty_p2pkh,
+            p2sh: empty_p2sh,
+            p2wpkh: empty_p2wpkh,
+            p2wsh: empty_p2wsh,
+            p2tr: empty_p2tr,
+            p2a: empty_p2a,
+        } = addresstype_to_typeindex_to_emptyaddressdata.unwrap();
+
+        thread::scope(|s| {
+            s.spawn(|| {
+                self.p2aaddressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2a
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2a.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            s.spawn(|| {
+                self.p2pk33addressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2pk33
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2pk33.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            s.spawn(|| {
+                self.p2pk65addressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2pk65
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2pk65.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            s.spawn(|| {
+                self.p2pkhaddressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2pkh
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2pkh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            s.spawn(|| {
+                self.p2shaddressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2sh
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2sh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            s.spawn(|| {
+                self.p2traddressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2tr
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2tr.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            s.spawn(|| {
+                self.p2wpkhaddressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2wpkh
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2wpkh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            s.spawn(|| {
+                self.p2wshaddressindex_to_addressdata.commit_(
+                    height,
+                    empty_p2wsh
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_addressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    p2wsh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+        });
+
+        thread::scope(|scope| {
+            scope.spawn(|| {
+                self.p2aaddressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2a.iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2a.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            scope.spawn(|| {
+                self.p2pk33addressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2pk33
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2pk33.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            scope.spawn(|| {
+                self.p2pk65addressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2pk65
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2pk65.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            scope.spawn(|| {
+                self.p2pkhaddressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2pkh
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2pkh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            scope.spawn(|| {
+                self.p2shaddressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2sh.iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2sh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            scope.spawn(|| {
+                self.p2traddressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2tr.iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2tr.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            scope.spawn(|| {
+                self.p2wpkhaddressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2wpkh
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2wpkh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+            scope.spawn(|| {
+                self.p2wshaddressindex_to_emptyaddressdata.commit_(
+                    height,
+                    p2wsh
+                        .iter()
+                        .filter(|(_, addressdata)| addressdata.is_from_emptyaddressdata())
+                        .map(|(typeindex, _)| (*typeindex).into()),
+                    empty_p2wsh.iter().map(|(typeindex, addressdata)| {
+                        ((*typeindex).into(), addressdata.deref().clone())
+                    }),
+                )
+            });
+        });
+
+        self.keyspace
+            .persist(PersistMode::SyncAll)
+            .map_err(|e| e.into())
+    }
+
+    pub fn rotate_memtables(&self) {
+        self.as_slice()
+            .into_iter()
+            .for_each(|store| store.rotate_memtable());
+    }
+
+    pub fn as_slice(&self) -> [&(dyn AnyStore + Send + Sync); 16] {
+        [
+            &self.p2aaddressindex_to_addressdata,
+            &self.p2aaddressindex_to_emptyaddressdata,
+            &self.p2pk33addressindex_to_addressdata,
+            &self.p2pk33addressindex_to_emptyaddressdata,
+            &self.p2pk65addressindex_to_addressdata,
+            &self.p2pk65addressindex_to_emptyaddressdata,
+            &self.p2pkhaddressindex_to_addressdata,
+            &self.p2pkhaddressindex_to_emptyaddressdata,
+            &self.p2shaddressindex_to_addressdata,
+            &self.p2shaddressindex_to_emptyaddressdata,
+            &self.p2traddressindex_to_addressdata,
+            &self.p2traddressindex_to_emptyaddressdata,
+            &self.p2wpkhaddressindex_to_addressdata,
+            &self.p2wpkhaddressindex_to_emptyaddressdata,
+            &self.p2wshaddressindex_to_addressdata,
+            &self.p2wshaddressindex_to_emptyaddressdata,
+        ]
+    }
+
+    fn as_mut_slice(&mut self) -> [&mut (dyn AnyStore + Send + Sync); 16] {
+        [
+            &mut self.p2aaddressindex_to_addressdata,
+            &mut self.p2aaddressindex_to_emptyaddressdata,
+            &mut self.p2pk33addressindex_to_addressdata,
+            &mut self.p2pk33addressindex_to_emptyaddressdata,
+            &mut self.p2pk65addressindex_to_addressdata,
+            &mut self.p2pk65addressindex_to_emptyaddressdata,
+            &mut self.p2pkhaddressindex_to_addressdata,
+            &mut self.p2pkhaddressindex_to_emptyaddressdata,
+            &mut self.p2shaddressindex_to_addressdata,
+            &mut self.p2shaddressindex_to_emptyaddressdata,
+            &mut self.p2traddressindex_to_addressdata,
+            &mut self.p2traddressindex_to_emptyaddressdata,
+            &mut self.p2wpkhaddressindex_to_addressdata,
+            &mut self.p2wpkhaddressindex_to_emptyaddressdata,
+            &mut self.p2wshaddressindex_to_addressdata,
+            &mut self.p2wshaddressindex_to_emptyaddressdata,
+        ]
+    }
 }

crates/brk_computer/src/vecs/cointime.rs

@@ -264,7 +264,7 @@ impl Vecs {
         stateful: &stateful::Vecs,
         exit: &Exit,
     ) -> color_eyre::Result<()> {
-        let circulating_supply = &stateful.utxos_vecs.all.1.height_to_supply;
+        let circulating_supply = &stateful.utxo_vecs.all.1.height_to_supply;
 
         self.indexes_to_coinblocks_created.compute_all(
             indexer,
@@ -282,7 +282,7 @@ impl Vecs {
         )?;
 
         let indexes_to_coinblocks_destroyed =
-            &stateful.utxos_vecs.all.1.indexes_to_coinblocks_destroyed;
+            &stateful.utxo_vecs.all.1.indexes_to_coinblocks_destroyed;
 
         self.indexes_to_coinblocks_stored.compute_all(
             indexer,
@@ -392,7 +392,7 @@ impl Vecs {
 
         if let Some(fetched) = fetched {
             let realized_cap = stateful
-                .utxos_vecs
+                .utxo_vecs
                 .all
                 .1
                 .height_to_realized_cap
@@ -400,7 +400,7 @@ impl Vecs {
                 .unwrap();
 
             let realized_price = stateful
-                .utxos_vecs
+                .utxo_vecs
                 .all
                 .1
                 .indexes_to_realized_price

crates/brk_computer/src/vecs/fetched.rs

@@ -426,7 +426,13 @@ impl Vecs {
             starting_indexes.dateindex,
             &indexes.dateindex_to_date,
             |(di, d, this)| {
-                let mut ohlc = fetcher.get_date(d).unwrap();
+                let mut ohlc = fetcher.get_date(d).unwrap_or_else(|_| {
+                    this.get_or_read(di, &this.mmap().load())
+                        .unwrap()
+                        .unwrap()
+                        .into_owned()
+                });
+
                 if let Some(prev) = di.decremented() {
                     let prev_open = *this
                         .get_or_read(prev, &this.mmap().load())

crates/brk_computer/src/vecs/grouped/builder.rs

@@ -45,16 +45,6 @@ where
     ) -> color_eyre::Result<Self> {
         let only_one_active = options.is_only_one_active();
 
-        let prefix = |s: &str| format!("{s}_{name}");
-
-        let maybe_prefix = |s: &str| {
-            if only_one_active {
-                name.to_string()
-            } else {
-                prefix(s)
-            }
-        };
-
         let suffix = |s: &str| format!("{name}_{s}");
 
         let maybe_suffix = |s: &str| {
@@ -70,7 +60,7 @@ where
                 Box::new(
                     EagerVec::forced_import(
                         path,
-                        &maybe_prefix("first"),
+                        &maybe_suffix("first"),
                         version + VERSION + Version::ZERO,
                         format,
                     )
@@ -130,7 +120,7 @@ where
                 Box::new(
                     EagerVec::forced_import(
                         path,
-                        &(if !options.last {
+                        &(if !options.last && !options.average && !options.min && !options.max {
                             name.to_string()
                         } else {
                             maybe_suffix("sum")
@@ -145,7 +135,7 @@ where
                 Box::new(
                     EagerVec::forced_import(
                         path,
-                        &prefix("cumulative"),
+                        &suffix("cumulative"),
                         version + VERSION + Version::ZERO,
                         format,
                     )
@@ -221,7 +211,7 @@ where
             cumulative_vec.iter().unwrap_get_inner(index)
         });
         source.iter_at(index).try_for_each(|(i, v)| -> Result<()> {
-            cumulative = cumulative.clone() + v.into_inner();
+            cumulative = cumulative.clone() + v.into_owned();
             cumulative_vec.forced_push_at(i, cumulative.clone(), exit)
         })?;
 
@@ -261,7 +251,7 @@ where
         first_indexes
             .iter_at(index)
             .try_for_each(|(i, first_index)| -> Result<()> {
-                let first_index = first_index.into_inner();
+                let first_index = first_index.into_owned();
 
                 let count_index = count_indexes_iter.unwrap_get_inner(i);
 
@@ -284,7 +274,7 @@ where
                     //     dbg!(first_index, count_index, last_index);
                     // })
                     // .unwrap()
-                    // .into_inner();
+                    // .into_owned();
                     last.forced_push_at(index, v, exit)?;
                 }
 
@@ -304,7 +294,7 @@ where
                     source_iter.set(first_index);
                     let mut values = (&mut source_iter)
                         .take(*count_index)
-                        .map(|(_, v)| v.into_inner())
+                        .map(|(_, v)| v.into_owned())
                         .collect::<Vec<_>>();
 
                     if needs_sorted {
@@ -435,7 +425,7 @@ where
         first_indexes
             .iter_at(index)
             .try_for_each(|(i, first_index, ..)| -> Result<()> {
-                let first_index = first_index.into_inner();
+                let first_index = first_index.into_owned();
 
                 let count_index = count_indexes_iter.unwrap_get_inner(i);
 
@@ -473,7 +463,7 @@ where
                             source_max_iter.set(first_index);
                             let mut values = source_max_iter
                                 .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
                             values.sort_unstable();
                             max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
@@ -484,7 +474,7 @@ where
                             source_min_iter.set(first_index);
                             let mut values = source_min_iter
                                 .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
                             values.sort_unstable();
                             min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
@@ -497,7 +487,7 @@ where
                             source_average_iter.set(first_index);
                             let values = source_average_iter
                                 .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
 
                             let len = values.len();
@@ -513,7 +503,7 @@ where
                             source_sum_iter.set(first_index);
                             let values = source_sum_iter
                                 .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
 
                             let sum = values.into_iter().fold(T::from(0), |a, b| a + b);

crates/brk_computer/src/vecs/grouped/from_height.rs

@@ -24,6 +24,7 @@ where
     pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
     pub monthindex: ComputedVecBuilder<MonthIndex, T>,
     pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    // 6 months
     pub yearindex: ComputedVecBuilder<YearIndex, T>,
     // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
     pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
@@ -144,9 +145,9 @@ where
         indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
-        height: Option<&impl AnyIterableVec<Height, T>>,
+        height_vec: Option<&impl AnyIterableVec<Height, T>>,
     ) -> color_eyre::Result<()> {
-        if let Some(height) = height {
+        if let Some(height) = height_vec {
             self.height_extra
                 .extend(starting_indexes.height, height, exit)?;
 

crates/brk_computer/src/vecs/grouped/from_height_strict.rs

@@ -5,7 +5,7 @@ use brk_exit::Exit;
 use brk_indexer::Indexer;
 use brk_vec::{AnyCollectableVec, EagerVec, Format};
 
-use crate::vecs::{Indexes, indexes};
+use crate::vecs::{indexes, Indexes};
 
 use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
 

crates/brk_computer/src/vecs/grouped/ratio_from_dateindex.rs

@@ -677,7 +677,7 @@ impl ComputedRatioVecsFromDateIndex {
                         .unwrap()
                         .forced_push_at(index, nan, exit)?;
                 } else {
-                    let ratio = ratio.into_inner();
+                    let ratio = ratio.into_owned();
                     let pos = sorted.binary_search(&ratio).unwrap_or_else(|pos| pos);
                     sorted.insert(pos, ratio);
                     self.ratio_p0_1.dateindex.as_mut().unwrap().forced_push_at(

crates/brk_computer/src/vecs/grouped/value_from_txindex.rs

@@ -69,7 +69,7 @@ impl ComputedValueVecsFromTxindex {
             source.map_or_else(|| sats.txindex.as_ref().unwrap().boxed_clone(), |s| s),
             |txindex: TxIndex, iter| {
                 iter.next_at(txindex.unwrap_to_usize()).map(|(_, value)| {
-                    let sats = value.into_inner();
+                    let sats = value.into_owned();
                     Bitcoin::from(sats)
                 })
             },
@@ -100,14 +100,14 @@ impl ComputedValueVecsFromTxindex {
                  height_to_close_iter| {
                     let txindex = txindex.unwrap_to_usize();
                     txindex_to_btc_iter.next_at(txindex).and_then(|(_, value)| {
-                        let btc = value.into_inner();
+                        let btc = value.into_owned();
                         txindex_to_height_iter
                             .next_at(txindex)
                             .and_then(|(_, value)| {
-                                let height = value.into_inner();
+                                let height = value.into_owned();
                                 height_to_close_iter
                                     .next_at(height.unwrap_to_usize())
-                                    .map(|(_, close)| *close.into_inner() * btc)
+                                    .map(|(_, close)| *close.into_owned() * btc)
                             })
                     })
                 },

crates/brk_computer/src/vecs/indexes.rs

@@ -144,10 +144,10 @@ impl Vecs {
                 txindex_to_first_inputindex_iter
                     .next_at(txindex)
                     .map(|(_, start)| {
-                        let start = usize::from(start.into_inner());
+                        let start = usize::from(start.into_owned());
                         let end = txindex_to_first_inputindex_iter
                             .next_at(txindex + 1)
-                            .map(|(_, v)| usize::from(v.into_inner()))
+                            .map(|(_, v)| usize::from(v.into_owned()))
                             .unwrap_or_else(|| inputindex_to_outputindex_iter.len());
                         StoredUsize::from((start..end).count())
                     })
@@ -167,10 +167,10 @@ impl Vecs {
                 txindex_to_first_outputindex_iter
                     .next_at(txindex)
                     .map(|(_, start)| {
-                        let start = usize::from(start.into_inner());
+                        let start = usize::from(start.into_owned());
                         let end = txindex_to_first_outputindex_iter
                             .next_at(txindex + 1)
-                            .map(|(_, v)| usize::from(v.into_inner()))
+                            .map(|(_, v)| usize::from(v.into_owned()))
                             .unwrap_or_else(|| outputindex_to_value_iter.len());
                         StoredUsize::from((start..end).count())
                     })

crates/brk_computer/src/vecs/mod.rs

@@ -1,4 +1,4 @@
-use std::{path::Path, thread};
+use std::path::Path;
 
 use brk_core::Version;
 use brk_exit::Exit;
@@ -20,6 +20,8 @@ pub mod transactions;
 pub use indexes::Indexes;
 use log::info;
 
+use crate::stores::Stores;
+
 const VERSION: Version = Version::ONE;
 
 #[derive(Clone)]
@@ -44,31 +46,22 @@ impl Vecs {
         computation: Computation,
         format: Format,
     ) -> color_eyre::Result<Self> {
-        let (indexes, fetched) = thread::scope(|s| {
-            let indexes_handle = s.spawn(|| {
-                indexes::Vecs::forced_import(
-                    path,
-                    version + VERSION + Version::ZERO,
-                    indexer,
-                    computation,
-                    format,
-                )
-                .unwrap()
-            });
+        let indexes = indexes::Vecs::forced_import(
+            path,
+            version + VERSION + Version::ZERO,
+            indexer,
+            computation,
+            format,
+        )?;
 
-            let fetch_handle = s.spawn(|| {
-                fetch.then(|| {
-                    fetched::Vecs::forced_import(
-                        path,
-                        version + VERSION + Version::ZERO,
-                        computation,
-                        format,
-                    )
-                    .unwrap()
-                })
-            });
-
-            (indexes_handle.join().unwrap(), fetch_handle.join().unwrap())
+        let fetched = fetch.then(|| {
+            fetched::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+            )
+            .unwrap()
         });
 
         Ok(Self {
@@ -130,6 +123,7 @@ impl Vecs {
         starting_indexes: brk_indexer::Indexes,
         fetcher: Option<&mut Fetcher>,
         exit: &Exit,
+        stores: &mut Stores,
     ) -> color_eyre::Result<()> {
         info!("Computing indexes...");
         let mut starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
@@ -187,6 +181,7 @@ impl Vecs {
             &self.market,
             &mut starting_indexes,
             exit,
+            stores,
         )?;
 
         self.cointime.compute(

crates/brk_computer/src/vecs/stateful/address_cohort.rs

@@ -0,0 +1,252 @@
+use std::{ops::Deref, path::Path};
+
+use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, StoredUsize, Version};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{
+    AnyCollectableVec, AnyIterableVec, AnyVec, Computation, EagerVec, Format, VecIterator,
+};
+
+use crate::{
+    states::AddressCohortState,
+    vecs::{
+        Indexes, fetched,
+        grouped::{ComputedVecsFromHeight, StorableVecGeneatorOptions},
+        indexes, market,
+        stateful::{
+            common,
+            r#trait::{CohortVecs, DynCohortVecs},
+        },
+    },
+};
+
+const VERSION: Version = Version::ZERO;
+
+#[derive(Clone)]
+pub struct Vecs {
+    starting_height: Height,
+
+    pub state: AddressCohortState,
+
+    pub inner: common::Vecs,
+
+    pub height_to_address_count: EagerVec<Height, StoredUsize>,
+    pub indexes_to_address_count: ComputedVecsFromHeight<StoredUsize>,
+}
+
+impl Vecs {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        path: &Path,
+        cohort_name: Option<&str>,
+        computation: Computation,
+        format: Format,
+        version: Version,
+        fetched: Option<&fetched::Vecs>,
+        states_path: &Path,
+        compute_relative_to_all: bool,
+    ) -> color_eyre::Result<Self> {
+        let compute_dollars = fetched.is_some();
+
+        let suffix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{name}_{s}"));
+
+        Ok(Self {
+            starting_height: Height::ZERO,
+            state: AddressCohortState::default_and_import(
+                states_path,
+                cohort_name.unwrap_or_default(),
+                compute_dollars,
+            )?,
+            height_to_address_count: EagerVec::forced_import(
+                path,
+                &suffix("address_count"),
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+            indexes_to_address_count: ComputedVecsFromHeight::forced_import(
+                path,
+                &suffix("address_count"),
+                false,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            inner: common::Vecs::forced_import(
+                path,
+                cohort_name,
+                computation,
+                format,
+                version,
+                fetched,
+                compute_relative_to_all,
+            )?,
+        })
+    }
+}
+
+impl DynCohortVecs for Vecs {
+    fn starting_height(&self) -> Height {
+        [
+            self.state.height().map_or(Height::MAX, |h| h.incremented()),
+            self.height_to_address_count.len().into(),
+            self.inner.starting_height(),
+        ]
+        .into_iter()
+        .min()
+        .unwrap()
+    }
+
+    fn init(&mut self, starting_height: Height) {
+        if starting_height > self.starting_height() {
+            unreachable!()
+        }
+
+        self.starting_height = starting_height;
+
+        if let Some(prev_height) = starting_height.decremented() {
+            self.state.address_count = *self
+                .height_to_address_count
+                .into_iter()
+                .unwrap_get_inner(prev_height);
+        }
+
+        self.inner
+            .init(&mut self.starting_height, &mut self.state.inner);
+    }
+
+    fn validate_computed_versions(&mut self, base_version: Version) -> Result<()> {
+        self.height_to_address_count
+            .validate_computed_version_or_reset_file(
+                base_version + self.height_to_address_count.inner_version(),
+            )?;
+
+        self.inner.validate_computed_versions(base_version)
+    }
+
+    fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()> {
+        if self.starting_height > height {
+            return Ok(());
+        }
+
+        self.height_to_address_count.forced_push_at(
+            height,
+            self.state.address_count.into(),
+            exit,
+        )?;
+
+        self.inner.forced_pushed_at(height, exit, &self.state.inner)
+    }
+
+    fn compute_then_force_push_unrealized_states(
+        &mut self,
+        height: Height,
+        height_price: Option<Dollars>,
+        dateindex: Option<DateIndex>,
+        date_price: Option<Option<Dollars>>,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.inner.compute_then_force_push_unrealized_states(
+            height,
+            height_price,
+            dateindex,
+            date_price,
+            exit,
+            &self.state.inner,
+        )
+    }
+
+    fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
+        self.height_to_address_count.safe_flush(exit)?;
+
+        self.inner
+            .safe_flush_stateful_vecs(height, exit, &mut self.state.inner)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part1(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        self.indexes_to_address_count.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&self.height_to_address_count),
+        )?;
+
+        self.inner
+            .compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)
+    }
+
+    fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.inner.vecs(),
+            self.indexes_to_address_count.vecs(),
+            vec![&self.height_to_address_count],
+        ]
+        .concat()
+    }
+}
+
+impl CohortVecs for Vecs {
+    fn compute_from_stateful(
+        &mut self,
+        starting_indexes: &Indexes,
+        others: &[&Self],
+        exit: &Exit,
+    ) -> Result<()> {
+        self.height_to_address_count.compute_sum_of_others(
+            starting_indexes.height,
+            others
+                .iter()
+                .map(|v| &v.height_to_address_count)
+                .collect::<Vec<_>>()
+                .as_slice(),
+            exit,
+        )?;
+        self.inner.compute_from_stateful(
+            starting_indexes,
+            &others.iter().map(|v| &v.inner).collect::<Vec<_>>(),
+            exit,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part2(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        market: &market::Vecs,
+        height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
+        dateindex_to_supply: &impl AnyIterableVec<DateIndex, Bitcoin>,
+        height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
+        dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        self.inner.compute_rest_part2(
+            indexer,
+            indexes,
+            fetched,
+            starting_indexes,
+            market,
+            height_to_supply,
+            dateindex_to_supply,
+            height_to_realized_cap,
+            dateindex_to_realized_cap,
+            exit,
+        )
+    }
+}
+
+impl Deref for Vecs {
+    type Target = common::Vecs;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}

crates/brk_computer/src/vecs/stateful/address_cohorts.rs

@@ -0,0 +1,508 @@
+use std::path::Path;
+
+use brk_core::{
+    AddressGroups, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, GroupFilter, Height,
+    Result, Version,
+};
+use brk_exit::Exit;
+use brk_vec::{Computation, Format};
+use derive_deref::{Deref, DerefMut};
+use rayon::prelude::*;
+
+use crate::vecs::{
+    Indexes, fetched,
+    stateful::{
+        address_cohort,
+        r#trait::{CohortVecs, DynCohortVecs},
+    },
+};
+
+const VERSION: Version = Version::new(0);
+
+#[derive(Clone, Deref, DerefMut)]
+pub struct Vecs(AddressGroups<(GroupFilter, address_cohort::Vecs)>);
+
+impl Vecs {
+    pub fn forced_import(
+        path: &Path,
+        version: Version,
+        _computation: Computation,
+        format: Format,
+        fetched: Option<&fetched::Vecs>,
+        states_path: &Path,
+    ) -> color_eyre::Result<Self> {
+        Ok(Self(
+            AddressGroups {
+                amount_range: ByAmountRange {
+                    _0sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_with_0sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1sat_to_10sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1sat_under_10sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10sats_to_100sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10sats_under_100sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100sats_to_1k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_100sats_under_1k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1k_sats_to_10k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1k_sats_under_10k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10k_sats_to_100k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10k_sats_under_100k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100k_sats_to_1m_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_100k_sats_under_1m_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1m_sats_to_10m_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1m_sats_under_10m_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10m_sats_to_1btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10m_sats_under_1btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1btc_to_10btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1btc_under_10btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10btc_to_100btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10btc_under_100btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100btc_to_1k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_100btc_under_1k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1k_btc_to_10k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1k_btc_under_10k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10k_btc_to_100k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10k_btc_under_100k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100k_btc_or_more: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_100k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                },
+                lt_amount: ByLowerThanAmount {
+                    _10sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_10sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_100sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_1k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_10k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_100k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1m_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_1m_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10m_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_10m_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_1btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_10btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_100btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_1k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_10k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_under_100k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                },
+                ge_amount: ByGreatEqualAmount {
+                    _1sat: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1sat"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_100sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100k_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_100k_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1m_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1m_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10m_sats: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10m_sats"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _100btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_100btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _1k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_1k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                    _10k_btc: address_cohort::Vecs::forced_import(
+                        path,
+                        Some("addrs_above_10k_btc"),
+                        _computation,
+                        format,
+                        version + VERSION + Version::ZERO,
+                        fetched,
+                        states_path,
+                        true,
+                    )?,
+                },
+            }
+            .into(),
+        ))
+    }
+
+    pub fn compute_overlapping_vecs(
+        &mut self,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        let by_size_range = self.0.amount_range.as_vec();
+
+        [
+            self.0
+                .ge_amount
+                .as_mut_vec()
+                .into_iter()
+                .map(|(filter, vecs)| {
+                    (
+                        vecs,
+                        by_size_range
+                            .into_iter()
+                            .filter(|(other, _)| filter.includes(other))
+                            .map(|(_, v)| v)
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .collect::<Vec<_>>(),
+            self.0
+                .lt_amount
+                .as_mut_vec()
+                .into_iter()
+                .map(|(filter, vecs)| {
+                    (
+                        vecs,
+                        by_size_range
+                            .into_iter()
+                            .filter(|(other, _)| filter.includes(other))
+                            .map(|(_, v)| v)
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .collect::<Vec<_>>(),
+        ]
+        .into_par_iter()
+        .flatten()
+        .try_for_each(|(vecs, stateful)| {
+            vecs.compute_from_stateful(starting_indexes, &stateful, exit)
+        })
+    }
+
+    pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
+        self.as_mut_separate_vecs()
+            .par_iter_mut()
+            .try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))
+    }
+}

crates/brk_computer/src/vecs/stateful/addresstype_to_addresscount.rs

@@ -0,0 +1,47 @@
+use brk_core::{ByAddressType, Height};
+use brk_vec::VecIterator;
+use derive_deref::{Deref, DerefMut};
+
+use crate::vecs::stateful::addresstype_to_height_to_addresscount::AddressTypeToHeightToAddressCount;
+
+#[derive(Debug, Default, Deref, DerefMut)]
+pub struct AddressTypeToAddressCount(ByAddressType<usize>);
+
+impl From<(&AddressTypeToHeightToAddressCount, Height)> for AddressTypeToAddressCount {
+    fn from((groups, starting_height): (&AddressTypeToHeightToAddressCount, Height)) -> Self {
+        if let Some(prev_height) = starting_height.decremented() {
+            Self(ByAddressType {
+                p2pk65: groups
+                    .p2pk65
+                    .into_iter()
+                    .unwrap_get_inner(prev_height)
+                    .into(),
+                p2pk33: groups
+                    .p2pk33
+                    .into_iter()
+                    .unwrap_get_inner(prev_height)
+                    .into(),
+                p2pkh: groups
+                    .p2pkh
+                    .into_iter()
+                    .unwrap_get_inner(prev_height)
+                    .into(),
+                p2sh: groups.p2sh.into_iter().unwrap_get_inner(prev_height).into(),
+                p2wpkh: groups
+                    .p2wpkh
+                    .into_iter()
+                    .unwrap_get_inner(prev_height)
+                    .into(),
+                p2wsh: groups
+                    .p2wsh
+                    .into_iter()
+                    .unwrap_get_inner(prev_height)
+                    .into(),
+                p2tr: groups.p2tr.into_iter().unwrap_get_inner(prev_height).into(),
+                p2a: groups.p2a.into_iter().unwrap_get_inner(prev_height).into(),
+            })
+        } else {
+            Default::default()
+        }
+    }
+}

crates/brk_computer/src/vecs/stateful/addresstype_to_height_to_addresscount.rs

@@ -0,0 +1,43 @@
+use brk_core::{ByAddressType, Height, Result, StoredUsize};
+use brk_exit::Exit;
+use brk_vec::EagerVec;
+use derive_deref::{Deref, DerefMut};
+
+use crate::vecs::stateful::addresstype_to_addresscount::AddressTypeToAddressCount;
+
+#[derive(Debug, Clone, Deref, DerefMut)]
+pub struct AddressTypeToHeightToAddressCount(ByAddressType<EagerVec<Height, StoredUsize>>);
+
+impl From<ByAddressType<EagerVec<Height, StoredUsize>>> for AddressTypeToHeightToAddressCount {
+    fn from(value: ByAddressType<EagerVec<Height, StoredUsize>>) -> Self {
+        Self(value)
+    }
+}
+
+impl AddressTypeToHeightToAddressCount {
+    pub fn forced_push_at(
+        &mut self,
+        height: Height,
+        addresstype_to_usize: &AddressTypeToAddressCount,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.p2pk65
+            .forced_push_at(height, addresstype_to_usize.p2pk65.into(), exit)?;
+        self.p2pk33
+            .forced_push_at(height, addresstype_to_usize.p2pk33.into(), exit)?;
+        self.p2pkh
+            .forced_push_at(height, addresstype_to_usize.p2pkh.into(), exit)?;
+        self.p2sh
+            .forced_push_at(height, addresstype_to_usize.p2sh.into(), exit)?;
+        self.p2wpkh
+            .forced_push_at(height, addresstype_to_usize.p2wpkh.into(), exit)?;
+        self.p2wsh
+            .forced_push_at(height, addresstype_to_usize.p2wsh.into(), exit)?;
+        self.p2tr
+            .forced_push_at(height, addresstype_to_usize.p2tr.into(), exit)?;
+        self.p2a
+            .forced_push_at(height, addresstype_to_usize.p2a.into(), exit)?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/vecs/stateful/addresstype_to_indexes_to_addresscount.rs

@@ -0,0 +1,89 @@
+use brk_core::{ByAddressType, StoredUsize};
+use brk_exit::Exit;
+use brk_vec::AnyCollectableVec;
+use derive_deref::{Deref, DerefMut};
+
+use crate::vecs::{
+    Indexes, grouped::ComputedVecsFromHeight, indexes,
+    stateful::addresstype_to_height_to_addresscount::AddressTypeToHeightToAddressCount,
+};
+
+#[derive(Clone, Deref, DerefMut)]
+pub struct AddressTypeToIndexesToAddressCount(ByAddressType<ComputedVecsFromHeight<StoredUsize>>);
+
+impl From<ByAddressType<ComputedVecsFromHeight<StoredUsize>>>
+    for AddressTypeToIndexesToAddressCount
+{
+    fn from(value: ByAddressType<ComputedVecsFromHeight<StoredUsize>>) -> Self {
+        Self(value)
+    }
+}
+
+impl AddressTypeToIndexesToAddressCount {
+    pub fn compute(
+        &mut self,
+        // height: Height,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        addresstype_to_height_to_addresscount: &AddressTypeToHeightToAddressCount,
+    ) -> color_eyre::Result<()> {
+        self.p2pk65.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2pk65),
+        )?;
+        self.p2pk33.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2pk33),
+        )?;
+        self.p2pkh.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2pkh),
+        )?;
+        self.p2sh.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2sh),
+        )?;
+        self.p2wpkh.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2wpkh),
+        )?;
+        self.p2wsh.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2wsh),
+        )?;
+        self.p2tr.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2tr),
+        )?;
+        self.p2a.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&addresstype_to_height_to_addresscount.p2a),
+        )?;
+        Ok(())
+    }
+    //
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        self.0
+            .as_typed_vec()
+            .into_iter()
+            .flat_map(|(_, v)| v.vecs())
+            .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/vecs/stateful/addresstype_to_typeindex_tree.rs

@@ -0,0 +1,50 @@
+use std::{collections::BTreeMap, mem};
+
+use brk_core::TypeIndex;
+use derive_deref::{Deref, DerefMut};
+
+use super::ByAddressType;
+
+#[derive(Debug, Deref, DerefMut)]
+pub struct AddressTypeToTypeIndexTree<T>(ByAddressType<BTreeMap<TypeIndex, T>>);
+
+impl<T> AddressTypeToTypeIndexTree<T> {
+    pub fn merge(&mut self, mut other: Self) {
+        Self::merge_(&mut self.p2pk65, &mut other.p2pk65);
+        Self::merge_(&mut self.p2pk33, &mut other.p2pk33);
+        Self::merge_(&mut self.p2pkh, &mut other.p2pkh);
+        Self::merge_(&mut self.p2sh, &mut other.p2sh);
+        Self::merge_(&mut self.p2wpkh, &mut other.p2wpkh);
+        Self::merge_(&mut self.p2wsh, &mut other.p2wsh);
+        Self::merge_(&mut self.p2tr, &mut other.p2tr);
+        Self::merge_(&mut self.p2a, &mut other.p2a);
+    }
+
+    fn merge_(own: &mut BTreeMap<TypeIndex, T>, other: &mut BTreeMap<TypeIndex, T>) {
+        if own.len() >= other.len() {
+            own.append(other);
+        } else {
+            other.append(own);
+            mem::swap(own, other);
+        }
+    }
+
+    pub fn unwrap(self) -> ByAddressType<BTreeMap<TypeIndex, T>> {
+        self.0
+    }
+}
+
+impl<T> Default for AddressTypeToTypeIndexTree<T> {
+    fn default() -> Self {
+        Self(ByAddressType {
+            p2pk65: BTreeMap::default(),
+            p2pk33: BTreeMap::default(),
+            p2pkh: BTreeMap::default(),
+            p2sh: BTreeMap::default(),
+            p2wpkh: BTreeMap::default(),
+            p2wsh: BTreeMap::default(),
+            p2tr: BTreeMap::default(),
+            p2a: BTreeMap::default(),
+        })
+    }
+}

crates/brk_computer/src/vecs/stateful/addresstype_to_typeindex_vec.rs

@@ -0,0 +1,30 @@
+use std::mem;
+
+use derive_deref::{Deref, DerefMut};
+
+use super::ByAddressType;
+
+#[derive(Debug, Default, Deref, DerefMut)]
+pub struct AddressTypeToVec<T>(ByAddressType<Vec<T>>);
+
+impl<T> AddressTypeToVec<T> {
+    pub fn merge(&mut self, mut other: Self) {
+        Self::merge_(&mut self.p2pk65, &mut other.p2pk65);
+        Self::merge_(&mut self.p2pk33, &mut other.p2pk33);
+        Self::merge_(&mut self.p2pkh, &mut other.p2pkh);
+        Self::merge_(&mut self.p2sh, &mut other.p2sh);
+        Self::merge_(&mut self.p2wpkh, &mut other.p2wpkh);
+        Self::merge_(&mut self.p2wsh, &mut other.p2wsh);
+        Self::merge_(&mut self.p2tr, &mut other.p2tr);
+        Self::merge_(&mut self.p2a, &mut other.p2a);
+    }
+
+    fn merge_(own: &mut Vec<T>, other: &mut Vec<T>) {
+        if own.len() >= other.len() {
+            own.append(other);
+        } else {
+            other.append(own);
+            mem::swap(own, other);
+        }
+    }
+}

crates/brk_computer/src/vecs/stateful/common.rs

@@ -1,4 +1,3 @@
-use core::panic;
 use std::path::Path;
 
 use brk_core::{
@@ -6,28 +5,27 @@ use brk_core::{
 };
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_state::CohortState;
 use brk_vec::{
-    AnyCollectableVec, AnyIterableVec, AnyVec, Computation, EagerVec, Format, StoredIndex,
-    VecIterator,
+    AnyCollectableVec, AnyIterableVec, AnyVec, Computation, EagerVec, Format, VecIterator,
 };
 
-use crate::vecs::{
-    Indexes, fetched,
-    grouped::{
-        ComputedHeightValueVecs, ComputedRatioVecsFromDateIndex, ComputedValueVecsFromDateIndex,
-        ComputedVecsFromDateIndex, ComputedVecsFromHeight, StorableVecGeneatorOptions,
+use crate::{
+    states::CohortState,
+    vecs::{
+        Indexes, fetched,
+        grouped::{
+            ComputedHeightValueVecs, ComputedRatioVecsFromDateIndex,
+            ComputedValueVecsFromDateIndex, ComputedVecsFromDateIndex, ComputedVecsFromHeight,
+            StorableVecGeneatorOptions,
+        },
+        indexes, market,
     },
-    indexes, market,
 };
 
 const VERSION: Version = Version::ZERO;
 
 #[derive(Clone)]
 pub struct Vecs {
-    starting_height: Height,
-    pub state: CohortState,
-
     // Cumulative
     pub height_to_realized_cap: Option<EagerVec<Height, Dollars>>,
     pub height_to_supply: EagerVec<Height, Sats>,
@@ -121,11 +119,11 @@ pub struct Vecs {
         Option<ComputedVecsFromDateIndex<StoredF64>>,
     pub indexes_to_supply_in_profit_relative_to_circulating_supply:
         Option<ComputedVecsFromDateIndex<StoredF64>>,
-    pub indexes_to_cumulative_net_realized_profit_and_loss_30d_change:
+    pub indexes_to_net_realized_profit_and_loss_cumulative_30d_change:
         Option<ComputedVecsFromDateIndex<Dollars>>,
-    pub indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_realized_cap:
+    pub indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap:
         Option<ComputedVecsFromDateIndex<StoredF32>>,
-    pub indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_market_cap:
+    pub indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap:
         Option<ComputedVecsFromDateIndex<StoredF32>>,
 }
 
@@ -138,7 +136,6 @@ impl Vecs {
         format: Format,
         version: Version,
         fetched: Option<&fetched::Vecs>,
-        states_path: &Path,
         compute_relative_to_all: bool,
     ) -> color_eyre::Result<Self> {
         let compute_dollars = fetched.is_some();
@@ -147,15 +144,7 @@ impl Vecs {
 
         let suffix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{name}_{s}"));
 
-        let state = CohortState::default_and_import(
-            states_path,
-            cohort_name.unwrap_or_default(),
-            compute_dollars,
-        )?;
-
         Ok(Self {
-            starting_height: Height::ZERO,
-            state,
 
             height_to_supply_in_profit: compute_dollars.then(|| {
                 EagerVec::forced_import(
@@ -940,10 +929,10 @@ impl Vecs {
                 format,
                 StorableVecGeneatorOptions::default().add_sum().add_cumulative(),
             )?,
-            indexes_to_cumulative_net_realized_profit_and_loss_30d_change: compute_dollars.then(|| {
+            indexes_to_net_realized_profit_and_loss_cumulative_30d_change: compute_dollars.then(|| {
                 ComputedVecsFromDateIndex::forced_import(
                     path,
-                    &format!("cumulative_{}", suffix("net_realized_profit_and_loss_30d_change")),
+                    &suffix("net_realized_profit_and_loss_cumulative_30d_change"),
                     true,
                     version + VERSION + Version::new(3),
                     format,
@@ -951,10 +940,10 @@ impl Vecs {
                 )
                 .unwrap()
             }),
-            indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_realized_cap: compute_dollars.then(|| {
+            indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap: compute_dollars.then(|| {
                 ComputedVecsFromDateIndex::forced_import(
                     path,
-                    &format!("cumulative_{}", suffix("net_realized_profit_and_loss_30d_change_relative_to_realized_cap")),
+                    &suffix("net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap"),
                     true,
                     version + VERSION + Version::new(3),
                     format,
@@ -962,10 +951,10 @@ impl Vecs {
                 )
                 .unwrap()
             }),
-            indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_market_cap: compute_dollars.then(|| {
+            indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap: compute_dollars.then(|| {
                 ComputedVecsFromDateIndex::forced_import(
                     path,
-                    &format!("cumulative_{}", suffix("net_realized_profit_and_loss_30d_change_relative_to_market_cap")),
+                    &suffix("net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap"),
                     true,
                     version + VERSION + Version::new(3),
                     format,
@@ -978,10 +967,6 @@ impl Vecs {
 
     pub fn starting_height(&self) -> Height {
         [
-            self.state
-                .price_to_amount
-                .height()
-                .map_or(usize::MAX, |h| h.incremented().unwrap_to_usize()),
             self.height_to_supply.len(),
             self.height_to_utxo_count.len(),
             self.height_to_realized_cap
@@ -1035,25 +1020,19 @@ impl Vecs {
         .unwrap()
     }
 
-    pub fn init(&mut self, starting_height: Height) {
-        if starting_height > self.starting_height() {
-            unreachable!()
-        }
-
-        self.starting_height = starting_height;
-
+    pub fn init(&mut self, starting_height: &mut Height, state: &mut CohortState) {
         if let Some(prev_height) = starting_height.decremented() {
-            self.state.supply.value = self
+            state.supply.value = self
                 .height_to_supply
                 .into_iter()
                 .unwrap_get_inner(prev_height);
-            self.state.supply.utxos = *self
+            state.supply.utxos = *self
                 .height_to_utxo_count
                 .into_iter()
                 .unwrap_get_inner(prev_height);
 
             if let Some(height_to_realized_cap) = self.height_to_realized_cap.as_mut() {
-                self.state.realized.as_mut().unwrap().cap = height_to_realized_cap
+                state.realized.as_mut().unwrap().cap = height_to_realized_cap
                     .into_iter()
                     .unwrap_get_inner(prev_height);
             }
@@ -1286,35 +1265,33 @@ impl Vecs {
         Ok(())
     }
 
-    pub fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()> {
-        if self.starting_height > height {
-            return Ok(());
-        }
-
+    pub fn forced_pushed_at(
+        &mut self,
+        height: Height,
+        exit: &Exit,
+        state: &CohortState,
+    ) -> Result<()> {
         self.height_to_supply
-            .forced_push_at(height, self.state.supply.value, exit)?;
+            .forced_push_at(height, state.supply.value, exit)?;
 
         self.height_to_utxo_count.forced_push_at(
             height,
-            StoredUsize::from(self.state.supply.utxos),
+            StoredUsize::from(state.supply.utxos),
             exit,
         )?;
 
         self.height_to_satblocks_destroyed.forced_push_at(
             height,
-            self.state.satblocks_destroyed,
+            state.satblocks_destroyed,
             exit,
         )?;
 
-        self.height_to_satdays_destroyed.forced_push_at(
-            height,
-            self.state.satdays_destroyed,
-            exit,
-        )?;
+        self.height_to_satdays_destroyed
+            .forced_push_at(height, state.satdays_destroyed, exit)?;
 
         if let Some(height_to_realized_cap) = self.height_to_realized_cap.as_mut() {
-            let realized = self.state.realized.as_ref().unwrap_or_else(|| {
-                dbg!((&self.state.realized, &self.state.supply));
+            let realized = state.realized.as_ref().unwrap_or_else(|| {
+                dbg!((&state.realized, &state.supply));
                 panic!();
             });
 
@@ -1355,6 +1332,7 @@ impl Vecs {
         dateindex: Option<DateIndex>,
         date_price: Option<Option<Dollars>>,
         exit: &Exit,
+        state: &CohortState,
     ) -> Result<()> {
         if let Some(height_price) = height_price {
             self.height_to_min_price_paid
@@ -1362,9 +1340,8 @@ impl Vecs {
                 .unwrap()
                 .forced_push_at(
                     height,
-                    self.state
-                        .price_to_amount
-                        .first_key_value()
+                    state
+                        .price_to_amount_first_key_value()
                         .map(|(&dollars, _)| dollars)
                         .unwrap_or(Dollars::NAN),
                     exit,
@@ -1374,17 +1351,15 @@ impl Vecs {
                 .unwrap()
                 .forced_push_at(
                     height,
-                    self.state
-                        .price_to_amount
-                        .last_key_value()
+                    state
+                        .price_to_amount_last_key_value()
                         .map(|(&dollars, _)| dollars)
                         .unwrap_or(Dollars::NAN),
                     exit,
                 )?;
 
-            let (height_unrealized_state, date_unrealized_state) = self
-                .state
-                .compute_unrealized_states(height_price, date_price.unwrap());
+            let (height_unrealized_state, date_unrealized_state) =
+                state.compute_unrealized_states(height_price, date_price.unwrap());
 
             self.height_to_supply_even
                 .as_mut()
@@ -1436,7 +1411,12 @@ impl Vecs {
         Ok(())
     }
 
-    pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
+    pub fn safe_flush_stateful_vecs(
+        &mut self,
+        height: Height,
+        exit: &Exit,
+        state: &mut CohortState,
+    ) -> Result<()> {
         self.height_to_supply.safe_flush(exit)?;
         self.height_to_utxo_count.safe_flush(exit)?;
         self.height_to_satdays_destroyed.safe_flush(exit)?;
@@ -1518,7 +1498,7 @@ impl Vecs {
                 .safe_flush(exit)?;
         }
 
-        self.state.commit(height)?;
+        state.commit(height)?;
 
         Ok(())
     }
@@ -2550,7 +2530,7 @@ impl Vecs {
                     },
                 )?;
 
-            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change
                 .as_mut()
                 .unwrap()
                 .compute_all(
@@ -2572,7 +2552,7 @@ impl Vecs {
                     },
                 )?;
 
-            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_realized_cap.
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap.
                 as_mut()
                 .unwrap()
                 .compute_all(
@@ -2583,14 +2563,14 @@ impl Vecs {
                     |v, _, _, starting_indexes, exit| {
                         v.compute_percentage(
                             starting_indexes.dateindex,
-                            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change.as_ref().unwrap().dateindex.as_ref().unwrap(),
+                            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change.as_ref().unwrap().dateindex.as_ref().unwrap(),
                             *dateindex_to_realized_cap.as_ref().unwrap(),
                             exit,
                         )
                     },
                 )?;
 
-            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_market_cap.
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap.
                 as_mut()
                 .unwrap()
                 .compute_all(
@@ -2601,7 +2581,7 @@ impl Vecs {
                     |v, _, _, starting_indexes, exit| {
                         v.compute_percentage(
                             starting_indexes.dateindex,
-                            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change.as_ref().unwrap().dateindex.as_ref().unwrap(),
+                            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change.as_ref().unwrap().dateindex.as_ref().unwrap(),
                             market.indexes_to_marketcap.dateindex.as_ref().unwrap(),
                             exit,
                         )
@@ -2935,11 +2915,11 @@ impl Vecs {
                 .map_or(vec![], |v| v.vecs()),
             self.indexes_to_coinblocks_destroyed.vecs(),
             self.indexes_to_coindays_destroyed.vecs(),
-            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change.as_ref()
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change.as_ref()
             .map_or(vec![], |v| v.vecs()),
-            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_realized_cap.as_ref()
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap.as_ref()
             .map_or(vec![], |v| v.vecs()),
-            self.indexes_to_cumulative_net_realized_profit_and_loss_30d_change_relative_to_market_cap.as_ref()
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap.as_ref()
             .map_or(vec![], |v| v.vecs()),
         ]
         .into_iter()

crates/brk_computer/src/vecs/stateful/outputs.rs

@@ -1,258 +0,0 @@
-use std::{collections::BTreeMap, ops::ControlFlow};
-
-use brk_core::{CheckedSub, Dollars, HalvingEpoch, Height, Result, Timestamp};
-use brk_exit::Exit;
-use brk_state::{BlockState, OutputFilter, Outputs, Transacted};
-use brk_vec::StoredIndex;
-use rayon::prelude::*;
-
-use crate::vecs::Indexes;
-
-use super::cohort;
-
-pub trait OutputCohorts {
-    fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp);
-    fn send(&mut self, height_to_sent: BTreeMap<Height, Transacted>, chain_state: &[BlockState]);
-    fn receive(&mut self, received: Transacted, height: Height, price: Option<Dollars>);
-    fn compute_overlapping_vecs(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()>;
-}
-
-impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
-    fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp) {
-        if chain_state.is_empty() {
-            return;
-        }
-
-        let prev_timestamp = chain_state.last().unwrap().timestamp;
-
-        self.by_date_range
-            .as_mut_vec()
-            .into_par_iter()
-            .for_each(|(filter, v)| {
-                let state = &mut v.state;
-
-                let _ = chain_state
-                    .iter()
-                    .try_for_each(|block_state| -> ControlFlow<()> {
-                        let prev_days_old = block_state
-                            .timestamp
-                            .difference_in_days_between(prev_timestamp);
-                        let days_old = block_state.timestamp.difference_in_days_between(timestamp);
-
-                        if prev_days_old == days_old {
-                            return ControlFlow::Continue(());
-                        }
-
-                        let is = filter.contains(days_old);
-                        let was = filter.contains(prev_days_old);
-
-                        if is && !was {
-                            state.increment(&block_state.supply, block_state.price);
-                        } else if was && !is {
-                            state.decrement(&block_state.supply, block_state.price);
-                        }
-
-                        ControlFlow::Continue(())
-                    });
-            });
-    }
-
-    fn send(&mut self, height_to_sent: BTreeMap<Height, Transacted>, chain_state: &[BlockState]) {
-        let mut time_based_vecs = self
-            .by_date_range
-            .as_mut_vec()
-            .into_iter()
-            .chain(self.by_epoch.as_mut_vec())
-            .collect::<Vec<_>>();
-
-        let last_timestamp = chain_state.last().unwrap().timestamp;
-        let current_price = chain_state.last().unwrap().price;
-
-        // dbg!(&height_to_sent);
-
-        height_to_sent.into_iter().for_each(|(height, sent)| {
-            let block_state = chain_state.get(height.unwrap_to_usize()).unwrap();
-            let prev_price = block_state.price;
-
-            let blocks_old = chain_state.len() - 1 - height.unwrap_to_usize();
-
-            let days_old = block_state
-                .timestamp
-                .difference_in_days_between(last_timestamp);
-
-            let days_old_foat = block_state
-                .timestamp
-                .difference_in_days_between_float(last_timestamp);
-
-            let older_than_hour =
-                jiff::Timestamp::from(last_timestamp.checked_sub(block_state.timestamp).unwrap())
-                    .as_second()
-                    >= 60 * 60;
-
-            time_based_vecs
-                .iter_mut()
-                .filter(|(filter, _)| match filter {
-                    OutputFilter::From(from) => *from <= days_old,
-                    OutputFilter::To(to) => *to > days_old,
-                    OutputFilter::Range(range) => range.contains(&days_old),
-                    OutputFilter::Epoch(epoch) => *epoch == HalvingEpoch::from(height),
-                    _ => unreachable!(),
-                })
-                .for_each(|(_, vecs)| {
-                    vecs.state.send(
-                        &sent.spendable_supply,
-                        current_price,
-                        prev_price,
-                        blocks_old,
-                        days_old_foat,
-                        older_than_hour,
-                    );
-                });
-
-            sent.by_type.spendable.as_typed_vec().into_iter().for_each(
-                |(output_type, supply_state)| {
-                    self.by_type.get_mut(output_type).1.state.send(
-                        supply_state,
-                        current_price,
-                        prev_price,
-                        blocks_old,
-                        days_old_foat,
-                        older_than_hour,
-                    )
-                },
-            );
-
-            sent.by_size_group
-                .into_iter()
-                .for_each(|(group, supply_state)| {
-                    self.by_size_range.get_mut(group).1.state.send(
-                        &supply_state,
-                        current_price,
-                        prev_price,
-                        blocks_old,
-                        days_old_foat,
-                        older_than_hour,
-                    );
-                });
-        });
-    }
-
-    fn receive(&mut self, received: Transacted, height: Height, price: Option<Dollars>) {
-        let supply_state = received.spendable_supply;
-
-        [
-            &mut self.by_date_range.start_to_1d.1,
-            &mut self.by_epoch.mut_vec_from_height(height).1,
-        ]
-        .into_iter()
-        .for_each(|v| {
-            v.state.receive(&supply_state, price);
-        });
-
-        self.by_type
-            .as_mut_vec()
-            .into_iter()
-            .for_each(|(filter, vecs)| {
-                let output_type = match filter {
-                    OutputFilter::Type(output_type) => *output_type,
-                    _ => unreachable!(),
-                };
-                vecs.state.receive(received.by_type.get(output_type), price)
-            });
-
-        received
-            .by_size_group
-            .into_iter()
-            .for_each(|(group, supply_state)| {
-                self.by_size_range
-                    .get_mut(group)
-                    .1
-                    .state
-                    .receive(&supply_state, price);
-            });
-    }
-
-    fn compute_overlapping_vecs(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()> {
-        let by_date_range = self.by_date_range.as_vec();
-        let by_size_range = self.by_size_range.as_vec();
-
-        [
-            vec![(&mut self.all.1, self.by_epoch.vecs().to_vec())],
-            self.by_from_date
-                .as_mut_vec()
-                .into_iter()
-                .map(|(filter, vecs)| {
-                    (
-                        vecs,
-                        by_date_range
-                            .into_iter()
-                            .filter(|(other, _)| filter.includes(other))
-                            .map(|(_, v)| v)
-                            .collect::<Vec<_>>(),
-                    )
-                })
-                .collect::<Vec<_>>(),
-            self.by_up_to_date
-                .as_mut_vec()
-                .into_iter()
-                .map(|(filter, vecs)| {
-                    (
-                        vecs,
-                        by_date_range
-                            .into_iter()
-                            .filter(|(other, _)| filter.includes(other))
-                            .map(|(_, v)| v)
-                            .collect::<Vec<_>>(),
-                    )
-                })
-                .collect::<Vec<_>>(),
-            self.by_term
-                .as_mut_vec()
-                .into_iter()
-                .map(|(filter, vecs)| {
-                    (
-                        vecs,
-                        by_date_range
-                            .into_iter()
-                            .filter(|(other, _)| filter.includes(other))
-                            .map(|(_, v)| v)
-                            .collect::<Vec<_>>(),
-                    )
-                })
-                .collect::<Vec<_>>(),
-            self.by_from_size
-                .as_mut_vec()
-                .into_iter()
-                .map(|(filter, vecs)| {
-                    (
-                        vecs,
-                        by_size_range
-                            .into_iter()
-                            .filter(|(other, _)| filter.includes(other))
-                            .map(|(_, v)| v)
-                            .collect::<Vec<_>>(),
-                    )
-                })
-                .collect::<Vec<_>>(),
-            self.by_up_to_size
-                .as_mut_vec()
-                .into_iter()
-                .map(|(filter, vecs)| {
-                    (
-                        vecs,
-                        by_size_range
-                            .into_iter()
-                            .filter(|(other, _)| filter.includes(other))
-                            .map(|(_, v)| v)
-                            .collect::<Vec<_>>(),
-                    )
-                })
-                .collect::<Vec<_>>(),
-        ]
-        .into_par_iter()
-        .flatten()
-        .try_for_each(|(vecs, stateful)| {
-            vecs.compute_from_stateful(starting_indexes, &stateful, exit)
-        })
-    }
-}

crates/brk_computer/src/vecs/stateful/trait.rs

@@ -0,0 +1,63 @@
+use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, Version};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, AnyIterableVec};
+
+use crate::vecs::{Indexes, fetched, indexes, market};
+
+pub trait DynCohortVecs: Send + Sync {
+    fn starting_height(&self) -> Height;
+
+    fn init(&mut self, starting_height: Height);
+
+    fn validate_computed_versions(&mut self, base_version: Version) -> Result<()>;
+
+    fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()>;
+
+    fn compute_then_force_push_unrealized_states(
+        &mut self,
+        height: Height,
+        height_price: Option<Dollars>,
+        dateindex: Option<DateIndex>,
+        date_price: Option<Option<Dollars>>,
+        exit: &Exit,
+    ) -> Result<()>;
+
+    fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()>;
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part1(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> color_eyre::Result<()>;
+
+    fn vecs(&self) -> Vec<&dyn AnyCollectableVec>;
+}
+
+pub trait CohortVecs: DynCohortVecs {
+    fn compute_from_stateful(
+        &mut self,
+        starting_indexes: &Indexes,
+        others: &[&Self],
+        exit: &Exit,
+    ) -> Result<()>;
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part2(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        market: &market::Vecs,
+        height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
+        dateindex_to_supply: &impl AnyIterableVec<DateIndex, Bitcoin>,
+        height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
+        dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+        exit: &Exit,
+    ) -> color_eyre::Result<()>;
+}

crates/brk_computer/src/vecs/stateful/utxo_cohort.rs

@@ -0,0 +1,186 @@
+use std::{ops::Deref, path::Path};
+
+use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, Version};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, Format};
+
+use crate::{
+    UTXOCohortState,
+    vecs::{
+        Indexes, fetched, indexes, market,
+        stateful::{
+            common,
+            r#trait::{CohortVecs, DynCohortVecs},
+        },
+    },
+};
+
+#[derive(Clone)]
+pub struct Vecs {
+    starting_height: Height,
+
+    pub state: UTXOCohortState,
+
+    inner: common::Vecs,
+}
+
+impl Vecs {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        path: &Path,
+        cohort_name: Option<&str>,
+        computation: Computation,
+        format: Format,
+        version: Version,
+        fetched: Option<&fetched::Vecs>,
+        states_path: &Path,
+        compute_relative_to_all: bool,
+    ) -> color_eyre::Result<Self> {
+        let compute_dollars = fetched.is_some();
+
+        Ok(Self {
+            starting_height: Height::ZERO,
+
+            state: UTXOCohortState::default_and_import(
+                states_path,
+                cohort_name.unwrap_or_default(),
+                compute_dollars,
+            )?,
+
+            inner: common::Vecs::forced_import(
+                path,
+                cohort_name,
+                computation,
+                format,
+                version,
+                fetched,
+                compute_relative_to_all,
+            )?,
+        })
+    }
+}
+
+impl DynCohortVecs for Vecs {
+    fn starting_height(&self) -> Height {
+        [
+            self.state.height().map_or(Height::MAX, |h| h.incremented()),
+            self.inner.starting_height(),
+        ]
+        .into_iter()
+        .min()
+        .unwrap()
+    }
+
+    fn init(&mut self, starting_height: Height) {
+        if starting_height > self.starting_height() {
+            unreachable!()
+        }
+
+        self.starting_height = starting_height;
+
+        self.inner.init(&mut self.starting_height, &mut self.state);
+    }
+
+    fn validate_computed_versions(&mut self, base_version: Version) -> Result<()> {
+        self.inner.validate_computed_versions(base_version)
+    }
+
+    fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()> {
+        if self.starting_height > height {
+            return Ok(());
+        }
+
+        self.inner.forced_pushed_at(height, exit, &self.state)
+    }
+
+    fn compute_then_force_push_unrealized_states(
+        &mut self,
+        height: Height,
+        height_price: Option<Dollars>,
+        dateindex: Option<DateIndex>,
+        date_price: Option<Option<Dollars>>,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.inner.compute_then_force_push_unrealized_states(
+            height,
+            height_price,
+            dateindex,
+            date_price,
+            exit,
+            &self.state,
+        )
+    }
+
+    fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
+        self.inner
+            .safe_flush_stateful_vecs(height, exit, &mut self.state)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part1(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        self.inner
+            .compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)
+    }
+
+    fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        self.inner.vecs()
+    }
+}
+
+impl CohortVecs for Vecs {
+    fn compute_from_stateful(
+        &mut self,
+        starting_indexes: &Indexes,
+        others: &[&Self],
+        exit: &Exit,
+    ) -> Result<()> {
+        self.inner.compute_from_stateful(
+            starting_indexes,
+            &others.iter().map(|v| &v.inner).collect::<Vec<_>>(),
+            exit,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part2(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        market: &market::Vecs,
+        height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
+        dateindex_to_supply: &impl AnyIterableVec<DateIndex, Bitcoin>,
+        height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
+        dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        self.inner.compute_rest_part2(
+            indexer,
+            indexes,
+            fetched,
+            starting_indexes,
+            market,
+            height_to_supply,
+            dateindex_to_supply,
+            height_to_realized_cap,
+            dateindex_to_realized_cap,
+            exit,
+        )
+    }
+}
+
+impl Deref for Vecs {
+    type Target = common::Vecs;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}

crates/brk_computer/src/vecs/stateful/withaddressdatasource.rs

@@ -0,0 +1,62 @@
+use brk_core::{AddressData, EmptyAddressData};
+
+#[derive(Debug)]
+pub enum WithAddressDataSource<T> {
+    New(T),
+    FromAddressDataStore(T),
+    FromEmptyAddressDataStore(T),
+}
+
+impl<T> WithAddressDataSource<T> {
+    pub fn is_new(&self) -> bool {
+        matches!(self, Self::New(_))
+    }
+
+    pub fn is_from_addressdata(&self) -> bool {
+        matches!(self, Self::FromAddressDataStore(_))
+    }
+
+    pub fn is_from_emptyaddressdata(&self) -> bool {
+        matches!(self, Self::FromEmptyAddressDataStore(_))
+    }
+
+    pub fn deref(&self) -> &T {
+        match self {
+            Self::New(v) => v,
+            Self::FromAddressDataStore(v) => v,
+            Self::FromEmptyAddressDataStore(v) => v,
+        }
+    }
+
+    pub fn deref_mut(&mut self) -> &mut T {
+        match self {
+            Self::New(v) => v,
+            Self::FromAddressDataStore(v) => v,
+            Self::FromEmptyAddressDataStore(v) => v,
+        }
+    }
+}
+
+impl From<WithAddressDataSource<EmptyAddressData>> for WithAddressDataSource<AddressData> {
+    fn from(value: WithAddressDataSource<EmptyAddressData>) -> Self {
+        match value {
+            WithAddressDataSource::New(v) => Self::New(v.into()),
+            WithAddressDataSource::FromAddressDataStore(v) => Self::FromAddressDataStore(v.into()),
+            WithAddressDataSource::FromEmptyAddressDataStore(v) => {
+                Self::FromEmptyAddressDataStore(v.into())
+            }
+        }
+    }
+}
+
+impl From<WithAddressDataSource<AddressData>> for WithAddressDataSource<EmptyAddressData> {
+    fn from(value: WithAddressDataSource<AddressData>) -> Self {
+        match value {
+            WithAddressDataSource::New(v) => Self::New(v.into()),
+            WithAddressDataSource::FromAddressDataStore(v) => Self::FromAddressDataStore(v.into()),
+            WithAddressDataSource::FromEmptyAddressDataStore(v) => {
+                Self::FromEmptyAddressDataStore(v.into())
+            }
+        }
+    }
+}

crates/brk_computer/src/vecs/transactions.rs

@@ -110,13 +110,13 @@ impl Vecs {
                 inputindex_to_outputindex_iter
                     .next_at(index.unwrap_to_usize())
                     .map(|(inputindex, outputindex)| {
-                        let outputindex = outputindex.into_inner();
+                        let outputindex = outputindex.into_owned();
                         if outputindex == OutputIndex::COINBASE {
                             Sats::ZERO
                         } else if let Some((_, value)) =
                             outputindex_to_value_iter.next_at(outputindex.unwrap_to_usize())
                         {
-                            value.into_inner()
+                            value.into_owned()
                         } else {
                             dbg!(inputindex, outputindex);
                             panic!()
@@ -138,12 +138,12 @@ impl Vecs {
                 txindex_to_base_size_iter
                     .next_at(index)
                     .map(|(_, base_size)| {
-                        let base_size = base_size.into_inner();
+                        let base_size = base_size.into_owned();
                         let total_size = txindex_to_total_size_iter
                             .next_at(index)
                             .unwrap()
                             .1
-                            .into_inner();
+                            .into_owned();
 
                         // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
                         let wu = usize::from(base_size) * 3 + usize::from(total_size);
@@ -164,7 +164,7 @@ impl Vecs {
                 let index = index.unwrap_to_usize();
                 iter.next_at(index).map(|(_, weight)| {
                     StoredUsize::from(
-                        bitcoin::Weight::from(weight.into_inner()).to_vbytes_ceil() as usize
+                        bitcoin::Weight::from(weight.into_owned()).to_vbytes_ceil() as usize
                     )
                 })
             },
@@ -182,12 +182,12 @@ impl Vecs {
                 txindex_to_height_iter
                     .next_at(index.unwrap_to_usize())
                     .map(|(_, height)| {
-                        let height = height.into_inner();
+                        let height = height.into_owned();
                         let txindex = height_to_first_txindex_iter
                             .next_at(height.unwrap_to_usize())
                             .unwrap()
                             .1
-                            .into_inner();
+                            .into_owned();
 
                         index == txindex
                     })
@@ -211,12 +211,12 @@ impl Vecs {
                 txindex_to_first_inputindex_iter
                     .next_at(txindex)
                     .map(|(_, first_index)| {
-                        let first_index = usize::from(first_index.into_inner());
+                        let first_index = usize::from(first_index.into_owned());
                         let count = *txindex_to_input_count_iter
                             .next_at(txindex)
                             .unwrap()
                             .1
-                            .into_inner();
+                            .into_owned();
                         let range = first_index..first_index + count;
                         range.into_iter().fold(Sats::ZERO, |total, inputindex| {
                             total
@@ -224,7 +224,7 @@ impl Vecs {
                                     .next_at(inputindex)
                                     .unwrap()
                                     .1
-                                    .into_inner()
+                                    .into_owned()
                         })
                     })
             },
@@ -260,12 +260,12 @@ impl Vecs {
                 txindex_to_first_outputindex_iter
                     .next_at(txindex)
                     .map(|(_, first_index)| {
-                        let first_index = usize::from(first_index.into_inner());
+                        let first_index = usize::from(first_index.into_owned());
                         let count = *txindex_to_output_count_iter
                             .next_at(txindex)
                             .unwrap()
                             .1
-                            .into_inner();
+                            .into_owned();
                         let range = first_index..first_index + count;
                         range.into_iter().fold(Sats::ZERO, |total, outputindex| {
                             total
@@ -273,7 +273,7 @@ impl Vecs {
                                     .next_at(outputindex)
                                     .unwrap()
                                     .1
-                                    .into_inner()
+                                    .into_owned()
                         })
                     })
             },
@@ -303,12 +303,12 @@ impl Vecs {
             |txindex: TxIndex, input_iter, output_iter| {
                 let txindex = txindex.unwrap_to_usize();
                 input_iter.next_at(txindex).and_then(|(_, value)| {
-                    let input = value.into_inner();
+                    let input = value.into_owned();
                     if input.is_zero() {
                         return Some(Sats::ZERO);
                     }
                     output_iter.next_at(txindex).map(|(_, value)| {
-                        let output = value.into_inner();
+                        let output = value.into_owned();
                         input.checked_sub(output).unwrap()
                     })
                 })
@@ -326,9 +326,9 @@ impl Vecs {
             |txindex: TxIndex, fee_iter, vsize_iter| {
                 let txindex = txindex.unwrap_to_usize();
                 fee_iter.next_at(txindex).and_then(|(_, value)| {
-                    let fee = value.into_inner();
+                    let fee = value.into_owned();
                     vsize_iter.next_at(txindex).map(|(_, value)| {
-                        let vsize = value.into_inner();
+                        let vsize = value.into_owned();
                         Feerate::from((fee, vsize))
                     })
                 })

crates/brk_core/src/enums/mod.rs

@@ -1,5 +0,0 @@
-mod error;
-mod value;
-
-pub use error::*;
-pub use value::*;

crates/brk_core/src/enums/value.rs

@@ -1,39 +0,0 @@
-use std::{fmt::Debug, ops::Deref};
-
-#[derive(Debug, Clone)]
-pub enum Value<'a, T> {
-    Ref(&'a T),
-    Owned(T),
-}
-
-impl<T> Value<'_, T>
-where
-    T: Sized + Debug + Clone,
-{
-    pub fn into_inner(self) -> T {
-        match self {
-            Self::Ref(t) => t.to_owned(),
-            Self::Owned(t) => t,
-        }
-    }
-}
-impl<T> Deref for Value<'_, T> {
-    type Target = T;
-    fn deref(&self) -> &Self::Target {
-        match self {
-            Self::Ref(t) => t,
-            Self::Owned(t) => t,
-        }
-    }
-}
-impl<T> AsRef<T> for Value<'_, T>
-where
-    T: Sized + Debug + Clone,
-{
-    fn as_ref(&self) -> &T {
-        match self {
-            Self::Ref(t) => t,
-            Self::Owned(t) => t,
-        }
-    }
-}

crates/brk_core/src/groups/address.rs

@@ -0,0 +1,55 @@
+use super::{ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, GroupFilter};
+
+#[derive(Default, Clone)]
+pub struct AddressGroups<T> {
+    pub ge_amount: ByGreatEqualAmount<T>,
+    pub amount_range: ByAmountRange<T>,
+    pub lt_amount: ByLowerThanAmount<T>,
+}
+
+impl<T> AddressGroups<T> {
+    pub fn as_mut_vecs(&mut self) -> Vec<&mut T> {
+        self.ge_amount
+            .as_mut_vec()
+            .into_iter()
+            .chain(self.amount_range.as_mut_vec())
+            .chain(self.lt_amount.as_mut_vec())
+            .collect::<Vec<_>>()
+    }
+
+    pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> {
+        self.amount_range
+            .as_mut_vec()
+            .into_iter()
+            .collect::<Vec<_>>()
+    }
+
+    pub fn as_mut_overlapping_vecs(&mut self) -> Vec<&mut T> {
+        self.lt_amount
+            .as_mut_vec()
+            .into_iter()
+            .chain(self.ge_amount.as_mut_vec())
+            .collect::<Vec<_>>()
+    }
+}
+
+impl<T> AddressGroups<(GroupFilter, T)> {
+    pub fn vecs(&self) -> Vec<&T> {
+        self.amount_range
+            .vecs()
+            .into_iter()
+            .chain(self.lt_amount.vecs())
+            .chain(self.ge_amount.vecs())
+            .collect::<Vec<_>>()
+    }
+}
+
+impl<T> From<AddressGroups<T>> for AddressGroups<(GroupFilter, T)> {
+    fn from(value: AddressGroups<T>) -> Self {
+        Self {
+            amount_range: ByAmountRange::from(value.amount_range),
+            lt_amount: ByLowerThanAmount::from(value.lt_amount),
+            ge_amount: ByGreatEqualAmount::from(value.ge_amount),
+        }
+    }
+}

crates/brk_core/src/groups/by_address_type.rs

@@ -0,0 +1,169 @@
+use std::{
+    mem,
+    ops::{Add, AddAssign},
+};
+
+use super::GroupFilter;
+use crate::OutputType;
+
+#[derive(Default, Clone, Debug)]
+pub struct ByAddressType<T> {
+    pub p2pk65: T,
+    pub p2pk33: T,
+    pub p2pkh: T,
+    pub p2sh: T,
+    pub p2wpkh: T,
+    pub p2wsh: T,
+    pub p2tr: T,
+    pub p2a: T,
+}
+
+impl<T> ByAddressType<T> {
+    pub fn get(&self, address_type: OutputType) -> Option<&T> {
+        match address_type {
+            OutputType::P2PK65 => Some(&self.p2pk65),
+            OutputType::P2PK33 => Some(&self.p2pk33),
+            OutputType::P2PKH => Some(&self.p2pkh),
+            OutputType::P2SH => Some(&self.p2sh),
+            OutputType::P2WPKH => Some(&self.p2wpkh),
+            OutputType::P2WSH => Some(&self.p2wsh),
+            OutputType::P2TR => Some(&self.p2tr),
+            OutputType::P2A => Some(&self.p2a),
+            _ => None,
+        }
+    }
+
+    pub fn get_mut(&mut self, address_type: OutputType) -> Option<&mut T> {
+        match address_type {
+            OutputType::P2PK65 => Some(&mut self.p2pk65),
+            OutputType::P2PK33 => Some(&mut self.p2pk33),
+            OutputType::P2PKH => Some(&mut self.p2pkh),
+            OutputType::P2SH => Some(&mut self.p2sh),
+            OutputType::P2WPKH => Some(&mut self.p2wpkh),
+            OutputType::P2WSH => Some(&mut self.p2wsh),
+            OutputType::P2TR => Some(&mut self.p2tr),
+            OutputType::P2A => Some(&mut self.p2a),
+            _ => None,
+        }
+    }
+
+    pub fn as_mut_vec(&mut self) -> [&mut T; 8] {
+        [
+            &mut self.p2pk65,
+            &mut self.p2pk33,
+            &mut self.p2pkh,
+            &mut self.p2sh,
+            &mut self.p2wpkh,
+            &mut self.p2wsh,
+            &mut self.p2tr,
+            &mut self.p2a,
+        ]
+    }
+
+    pub fn as_typed_vec(&self) -> [(OutputType, &T); 8] {
+        [
+            (OutputType::P2PK65, &self.p2pk65),
+            (OutputType::P2PK33, &self.p2pk33),
+            (OutputType::P2PKH, &self.p2pkh),
+            (OutputType::P2SH, &self.p2sh),
+            (OutputType::P2WPKH, &self.p2wpkh),
+            (OutputType::P2WSH, &self.p2wsh),
+            (OutputType::P2TR, &self.p2tr),
+            (OutputType::P2A, &self.p2a),
+        ]
+    }
+
+    pub fn as_mut_typed_vec(&mut self) -> [(OutputType, &mut T); 8] {
+        [
+            (OutputType::P2PK65, &mut self.p2pk65),
+            (OutputType::P2PK33, &mut self.p2pk33),
+            (OutputType::P2PKH, &mut self.p2pkh),
+            (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),
+        ]
+    }
+
+    pub fn into_typed_vec(&mut self) -> [(OutputType, T); 8]
+    where
+        T: Default,
+    {
+        [
+            (OutputType::P2PK65, mem::take(&mut self.p2pk65)),
+            (OutputType::P2PK33, mem::take(&mut self.p2pk33)),
+            (OutputType::P2PKH, mem::take(&mut self.p2pkh)),
+            (OutputType::P2SH, mem::take(&mut self.p2sh)),
+            (OutputType::P2WPKH, mem::take(&mut self.p2wpkh)),
+            (OutputType::P2WSH, mem::take(&mut self.p2wsh)),
+            (OutputType::P2TR, mem::take(&mut self.p2tr)),
+            (OutputType::P2A, mem::take(&mut self.p2a)),
+        ]
+    }
+}
+
+impl<T> ByAddressType<(GroupFilter, T)> {
+    pub fn vecs(&self) -> [&T; 8] {
+        [
+            &self.p2pk65.1,
+            &self.p2pk33.1,
+            &self.p2pkh.1,
+            &self.p2sh.1,
+            &self.p2wpkh.1,
+            &self.p2wsh.1,
+            &self.p2tr.1,
+            &self.p2a.1,
+        ]
+    }
+}
+
+impl<T> From<ByAddressType<T>> for ByAddressType<(GroupFilter, T)> {
+    fn from(value: ByAddressType<T>) -> Self {
+        Self {
+            p2pk65: (GroupFilter::Type(OutputType::P2PK65), value.p2pk65),
+            p2pk33: (GroupFilter::Type(OutputType::P2PK33), value.p2pk33),
+            p2pkh: (GroupFilter::Type(OutputType::P2PKH), value.p2pkh),
+            p2sh: (GroupFilter::Type(OutputType::P2SH), value.p2sh),
+            p2wpkh: (GroupFilter::Type(OutputType::P2WPKH), value.p2wpkh),
+            p2wsh: (GroupFilter::Type(OutputType::P2WSH), value.p2wsh),
+            p2tr: (GroupFilter::Type(OutputType::P2TR), value.p2tr),
+            p2a: (GroupFilter::Type(OutputType::P2A), value.p2a),
+        }
+    }
+}
+
+impl<T> Add for ByAddressType<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,
+            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,
+        }
+    }
+}
+
+impl<T> AddAssign for ByAddressType<T>
+where
+    T: AddAssign,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        self.p2pk65 += rhs.p2pk65;
+        self.p2pk33 += rhs.p2pk33;
+        self.p2pkh += rhs.p2pkh;
+        self.p2sh += rhs.p2sh;
+        self.p2wpkh += rhs.p2wpkh;
+        self.p2wsh += rhs.p2wsh;
+        self.p2tr += rhs.p2tr;
+        self.p2a += rhs.p2a;
+    }
+}

crates/brk_core/src/groups/by_age_range.rs

@@ -0,0 +1,131 @@
+use super::GroupFilter;
+
+#[derive(Default, Clone)]
+pub struct ByAgeRange<T> {
+    pub up_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_12y: T,
+    pub _12y_to_15y: T,
+    pub from_15y: T,
+}
+
+impl<T> From<ByAgeRange<T>> for ByAgeRange<(GroupFilter, T)> {
+    fn from(value: ByAgeRange<T>) -> Self {
+        Self {
+            up_to_1d: (GroupFilter::LowerThan(1), value.up_to_1d),
+            _1d_to_1w: (GroupFilter::Range(1..7), value._1d_to_1w),
+            _1w_to_1m: (GroupFilter::Range(7..30), value._1w_to_1m),
+            _1m_to_2m: (GroupFilter::Range(30..2 * 30), value._1m_to_2m),
+            _2m_to_3m: (GroupFilter::Range(2 * 30..3 * 30), value._2m_to_3m),
+            _3m_to_4m: (GroupFilter::Range(3 * 30..4 * 30), value._3m_to_4m),
+            _4m_to_5m: (GroupFilter::Range(4 * 30..5 * 30), value._4m_to_5m),
+            _5m_to_6m: (GroupFilter::Range(5 * 30..6 * 30), value._5m_to_6m),
+            _6m_to_1y: (GroupFilter::Range(6 * 30..365), value._6m_to_1y),
+            _1y_to_2y: (GroupFilter::Range(365..2 * 365), value._1y_to_2y),
+            _2y_to_3y: (GroupFilter::Range(2 * 365..3 * 365), value._2y_to_3y),
+            _3y_to_4y: (GroupFilter::Range(3 * 365..4 * 365), value._3y_to_4y),
+            _4y_to_5y: (GroupFilter::Range(4 * 365..5 * 365), value._4y_to_5y),
+            _5y_to_6y: (GroupFilter::Range(5 * 365..6 * 365), value._5y_to_6y),
+            _6y_to_7y: (GroupFilter::Range(6 * 365..7 * 365), value._6y_to_7y),
+            _7y_to_8y: (GroupFilter::Range(7 * 365..8 * 365), value._7y_to_8y),
+            _8y_to_10y: (GroupFilter::Range(8 * 365..10 * 365), value._8y_to_10y),
+            _10y_to_12y: (GroupFilter::Range(10 * 365..12 * 365), value._10y_to_12y),
+            _12y_to_15y: (GroupFilter::Range(12 * 365..15 * 365), value._12y_to_15y),
+            from_15y: (GroupFilter::GreaterOrEqual(15 * 365), value.from_15y),
+        }
+    }
+}
+
+impl<T> ByAgeRange<T> {
+    pub fn as_vec(&mut self) -> [&T; 20] {
+        [
+            &self.up_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_12y,
+            &self._12y_to_15y,
+            &self.from_15y,
+        ]
+    }
+
+    pub fn as_mut_vec(&mut self) -> [&mut T; 20] {
+        [
+            &mut self.up_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_12y,
+            &mut self._12y_to_15y,
+            &mut self.from_15y,
+        ]
+    }
+}
+
+impl<T> ByAgeRange<(GroupFilter, T)> {
+    pub fn vecs(&self) -> [&T; 20] {
+        [
+            &self.up_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_12y.1,
+            &self._12y_to_15y.1,
+            &self.from_15y.1,
+        ]
+    }
+}

crates/brk_core/src/groups/by_amount_range.rs

@@ -0,0 +1,257 @@
+use std::ops::{Add, AddAssign};
+
+use crate::Sats;
+
+use super::GroupFilter;
+
+#[derive(Debug, Default, Clone)]
+pub struct ByAmountRange<T> {
+    pub _0sats: T,
+    pub _1sat_to_10sats: T,
+    pub _10sats_to_100sats: T,
+    pub _100sats_to_1k_sats: T,
+    pub _1k_sats_to_10k_sats: T,
+    pub _10k_sats_to_100k_sats: T,
+    pub _100k_sats_to_1m_sats: T,
+    pub _1m_sats_to_10m_sats: T,
+    pub _10m_sats_to_1btc: T,
+    pub _1btc_to_10btc: T,
+    pub _10btc_to_100btc: T,
+    pub _100btc_to_1k_btc: T,
+    pub _1k_btc_to_10k_btc: T,
+    pub _10k_btc_to_100k_btc: T,
+    pub _100k_btc_or_more: T,
+}
+
+impl<T> From<ByAmountRange<T>> for ByAmountRange<(GroupFilter, T)> {
+    fn from(value: ByAmountRange<T>) -> Self {
+        #[allow(clippy::inconsistent_digit_grouping)]
+        Self {
+            _0sats: (GroupFilter::LowerThan(Sats::_1.into()), value._0sats),
+            _1sat_to_10sats: (
+                GroupFilter::Range(Sats::_1.into()..Sats::_10.into()),
+                value._1sat_to_10sats,
+            ),
+            _10sats_to_100sats: (
+                GroupFilter::Range(Sats::_10.into()..Sats::_100.into()),
+                value._10sats_to_100sats,
+            ),
+            _100sats_to_1k_sats: (
+                GroupFilter::Range(Sats::_100.into()..Sats::_1K.into()),
+                value._100sats_to_1k_sats,
+            ),
+            _1k_sats_to_10k_sats: (
+                GroupFilter::Range(Sats::_1K.into()..Sats::_10K.into()),
+                value._1k_sats_to_10k_sats,
+            ),
+            _10k_sats_to_100k_sats: (
+                GroupFilter::Range(Sats::_10K.into()..Sats::_100K.into()),
+                value._10k_sats_to_100k_sats,
+            ),
+            _100k_sats_to_1m_sats: (
+                GroupFilter::Range(Sats::_100K.into()..Sats::_1M.into()),
+                value._100k_sats_to_1m_sats,
+            ),
+            _1m_sats_to_10m_sats: (
+                GroupFilter::Range(Sats::_1M.into()..Sats::_10M.into()),
+                value._1m_sats_to_10m_sats,
+            ),
+            _10m_sats_to_1btc: (
+                GroupFilter::Range(Sats::_10M.into()..Sats::_1BTC.into()),
+                value._10m_sats_to_1btc,
+            ),
+            _1btc_to_10btc: (
+                GroupFilter::Range(Sats::_1BTC.into()..Sats::_10BTC.into()),
+                value._1btc_to_10btc,
+            ),
+            _10btc_to_100btc: (
+                GroupFilter::Range(Sats::_10BTC.into()..Sats::_100BTC.into()),
+                value._10btc_to_100btc,
+            ),
+            _100btc_to_1k_btc: (
+                GroupFilter::Range(Sats::_100BTC.into()..Sats::_1K_BTC.into()),
+                value._100btc_to_1k_btc,
+            ),
+            _1k_btc_to_10k_btc: (
+                GroupFilter::Range(Sats::_1K_BTC.into()..Sats::_10K_BTC.into()),
+                value._1k_btc_to_10k_btc,
+            ),
+            _10k_btc_to_100k_btc: (
+                GroupFilter::Range(Sats::_10K_BTC.into()..Sats::_100K_BTC.into()),
+                value._10k_btc_to_100k_btc,
+            ),
+            _100k_btc_or_more: (
+                GroupFilter::GreaterOrEqual(Sats::_100K_BTC.into()),
+                value._100k_btc_or_more,
+            ),
+        }
+    }
+}
+
+impl<T> ByAmountRange<T> {
+    #[allow(clippy::inconsistent_digit_grouping)]
+    pub fn get_mut(&mut self, value: Sats) -> &mut T {
+        if value == Sats::ZERO {
+            &mut self._0sats
+        } else if value < Sats::_10 {
+            &mut self._1sat_to_10sats
+        } else if value < Sats::_100 {
+            &mut self._10sats_to_100sats
+        } else if value < Sats::_1K {
+            &mut self._100sats_to_1k_sats
+        } else if value < Sats::_10K {
+            &mut self._1k_sats_to_10k_sats
+        } else if value < Sats::_100K {
+            &mut self._10k_sats_to_100k_sats
+        } else if value < Sats::_1M {
+            &mut self._100k_sats_to_1m_sats
+        } else if value < Sats::_10M {
+            &mut self._1m_sats_to_10m_sats
+        } else if value < Sats::_1BTC {
+            &mut self._10m_sats_to_1btc
+        } else if value < Sats::_10BTC {
+            &mut self._1btc_to_10btc
+        } else if value < Sats::_100BTC {
+            &mut self._10btc_to_100btc
+        } else if value < Sats::_1K_BTC {
+            &mut self._100btc_to_1k_btc
+        } else if value < Sats::_10K_BTC {
+            &mut self._1k_btc_to_10k_btc
+        } else if value < Sats::_100K_BTC {
+            &mut self._10k_btc_to_100k_btc
+        } else {
+            &mut self._100k_btc_or_more
+        }
+    }
+
+    pub fn as_vec(&self) -> [&T; 15] {
+        [
+            &self._0sats,
+            &self._1sat_to_10sats,
+            &self._10sats_to_100sats,
+            &self._100sats_to_1k_sats,
+            &self._1k_sats_to_10k_sats,
+            &self._10k_sats_to_100k_sats,
+            &self._100k_sats_to_1m_sats,
+            &self._1m_sats_to_10m_sats,
+            &self._10m_sats_to_1btc,
+            &self._1btc_to_10btc,
+            &self._10btc_to_100btc,
+            &self._100btc_to_1k_btc,
+            &self._1k_btc_to_10k_btc,
+            &self._10k_btc_to_100k_btc,
+            &self._100k_btc_or_more,
+        ]
+    }
+
+    pub fn as_typed_vec(&self) -> [(Sats, &T); 15] {
+        [
+            (Sats::ZERO, &self._0sats),
+            (Sats::_1, &self._1sat_to_10sats),
+            (Sats::_10, &self._10sats_to_100sats),
+            (Sats::_100, &self._100sats_to_1k_sats),
+            (Sats::_1K, &self._1k_sats_to_10k_sats),
+            (Sats::_10K, &self._10k_sats_to_100k_sats),
+            (Sats::_100K, &self._100k_sats_to_1m_sats),
+            (Sats::_1M, &self._1m_sats_to_10m_sats),
+            (Sats::_10M, &self._10m_sats_to_1btc),
+            (Sats::_1BTC, &self._1btc_to_10btc),
+            (Sats::_10BTC, &self._10btc_to_100btc),
+            (Sats::_100BTC, &self._100btc_to_1k_btc),
+            (Sats::_1K_BTC, &self._1k_btc_to_10k_btc),
+            (Sats::_10K_BTC, &self._10k_btc_to_100k_btc),
+            (Sats::_100K_BTC, &self._100k_btc_or_more),
+        ]
+    }
+
+    pub fn as_mut_vec(&mut self) -> [&mut T; 15] {
+        [
+            &mut self._0sats,
+            &mut self._1sat_to_10sats,
+            &mut self._10sats_to_100sats,
+            &mut self._100sats_to_1k_sats,
+            &mut self._1k_sats_to_10k_sats,
+            &mut self._10k_sats_to_100k_sats,
+            &mut self._100k_sats_to_1m_sats,
+            &mut self._1m_sats_to_10m_sats,
+            &mut self._10m_sats_to_1btc,
+            &mut self._1btc_to_10btc,
+            &mut self._10btc_to_100btc,
+            &mut self._100btc_to_1k_btc,
+            &mut self._1k_btc_to_10k_btc,
+            &mut self._10k_btc_to_100k_btc,
+            &mut self._100k_btc_or_more,
+        ]
+    }
+}
+
+impl<T> ByAmountRange<(GroupFilter, T)> {
+    pub fn vecs(&self) -> [&T; 15] {
+        [
+            &self._0sats.1,
+            &self._1sat_to_10sats.1,
+            &self._10sats_to_100sats.1,
+            &self._100sats_to_1k_sats.1,
+            &self._1k_sats_to_10k_sats.1,
+            &self._10k_sats_to_100k_sats.1,
+            &self._100k_sats_to_1m_sats.1,
+            &self._1m_sats_to_10m_sats.1,
+            &self._10m_sats_to_1btc.1,
+            &self._1btc_to_10btc.1,
+            &self._10btc_to_100btc.1,
+            &self._100btc_to_1k_btc.1,
+            &self._1k_btc_to_10k_btc.1,
+            &self._10k_btc_to_100k_btc.1,
+            &self._100k_btc_or_more.1,
+        ]
+    }
+}
+
+impl<T> Add for ByAmountRange<T>
+where
+    T: Add<Output = T>,
+{
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            _0sats: self._0sats + rhs._0sats,
+            _1sat_to_10sats: self._1sat_to_10sats + rhs._1sat_to_10sats,
+            _10sats_to_100sats: self._10sats_to_100sats + rhs._10sats_to_100sats,
+            _100sats_to_1k_sats: self._100sats_to_1k_sats + rhs._100sats_to_1k_sats,
+            _1k_sats_to_10k_sats: self._1k_sats_to_10k_sats + rhs._1k_sats_to_10k_sats,
+            _10k_sats_to_100k_sats: self._10k_sats_to_100k_sats + rhs._10k_sats_to_100k_sats,
+            _100k_sats_to_1m_sats: self._100k_sats_to_1m_sats + rhs._100k_sats_to_1m_sats,
+            _1m_sats_to_10m_sats: self._1m_sats_to_10m_sats + rhs._1m_sats_to_10m_sats,
+            _10m_sats_to_1btc: self._10m_sats_to_1btc + rhs._10m_sats_to_1btc,
+            _1btc_to_10btc: self._1btc_to_10btc + rhs._1btc_to_10btc,
+            _10btc_to_100btc: self._10btc_to_100btc + rhs._10btc_to_100btc,
+            _100btc_to_1k_btc: self._100btc_to_1k_btc + rhs._100btc_to_1k_btc,
+            _1k_btc_to_10k_btc: self._1k_btc_to_10k_btc + rhs._1k_btc_to_10k_btc,
+            _10k_btc_to_100k_btc: self._10k_btc_to_100k_btc + rhs._10k_btc_to_100k_btc,
+            _100k_btc_or_more: self._100k_btc_or_more + rhs._100k_btc_or_more,
+        }
+    }
+}
+
+impl<T> AddAssign for ByAmountRange<T>
+where
+    T: AddAssign,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        self._0sats += rhs._0sats;
+        self._1sat_to_10sats += rhs._1sat_to_10sats;
+        self._10sats_to_100sats += rhs._10sats_to_100sats;
+        self._100sats_to_1k_sats += rhs._100sats_to_1k_sats;
+        self._1k_sats_to_10k_sats += rhs._1k_sats_to_10k_sats;
+        self._10k_sats_to_100k_sats += rhs._10k_sats_to_100k_sats;
+        self._100k_sats_to_1m_sats += rhs._100k_sats_to_1m_sats;
+        self._1m_sats_to_10m_sats += rhs._1m_sats_to_10m_sats;
+        self._10m_sats_to_1btc += rhs._10m_sats_to_1btc;
+        self._1btc_to_10btc += rhs._1btc_to_10btc;
+        self._10btc_to_100btc += rhs._10btc_to_100btc;
+        self._100btc_to_1k_btc += rhs._100btc_to_1k_btc;
+        self._1k_btc_to_10k_btc += rhs._1k_btc_to_10k_btc;
+        self._10k_btc_to_100k_btc += rhs._10k_btc_to_100k_btc;
+        self._100k_btc_or_more += rhs._100k_btc_or_more;
+    }
+}

crates/brk_core/src/groups/by_epoch.rs

@@ -1,9 +1,9 @@
-use brk_core::{HalvingEpoch, Height};
+use crate::{HalvingEpoch, Height};
 
-use super::OutputFilter;
+use super::GroupFilter;
 
 #[derive(Default, Clone)]
-pub struct OutputsByEpoch<T> {
+pub struct ByEpoch<T> {
     pub _0: T,
     pub _1: T,
     pub _2: T,
@@ -11,19 +11,19 @@ pub struct OutputsByEpoch<T> {
     pub _4: T,
 }
 
-impl<T> From<OutputsByEpoch<T>> for OutputsByEpoch<(OutputFilter, T)> {
-    fn from(value: OutputsByEpoch<T>) -> Self {
+impl<T> From<ByEpoch<T>> for ByEpoch<(GroupFilter, T)> {
+    fn from(value: ByEpoch<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),
+            _0: (GroupFilter::Epoch(HalvingEpoch::new(0)), value._0),
+            _1: (GroupFilter::Epoch(HalvingEpoch::new(1)), value._1),
+            _2: (GroupFilter::Epoch(HalvingEpoch::new(2)), value._2),
+            _3: (GroupFilter::Epoch(HalvingEpoch::new(3)), value._3),
+            _4: (GroupFilter::Epoch(HalvingEpoch::new(4)), value._4),
         }
     }
 }
 
-impl<T> OutputsByEpoch<T> {
+impl<T> ByEpoch<T> {
     pub fn as_mut_vec(&mut self) -> [&mut T; 5] {
         [
             &mut self._0,
@@ -52,7 +52,7 @@ impl<T> OutputsByEpoch<T> {
     }
 }
 
-impl<T> OutputsByEpoch<(OutputFilter, T)> {
+impl<T> ByEpoch<(GroupFilter, T)> {
     pub fn vecs(&self) -> [&T; 5] {
         [&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1]
     }

crates/brk_core/src/groups/by_ge_amount.rs

@@ -0,0 +1,110 @@
+use crate::Sats;
+
+use super::GroupFilter;
+
+#[derive(Default, Clone)]
+pub struct ByGreatEqualAmount<T> {
+    pub _1sat: T,
+    pub _10sats: T,
+    pub _100sats: T,
+    pub _1k_sats: T,
+    pub _10k_sats: T,
+    pub _100k_sats: T,
+    pub _1m_sats: T,
+    pub _10m_sats: T,
+    pub _1btc: T,
+    pub _10btc: T,
+    pub _100btc: T,
+    pub _1k_btc: T,
+    pub _10k_btc: T,
+}
+
+impl<T> ByGreatEqualAmount<T> {
+    pub fn as_mut_vec(&mut self) -> [&mut T; 13] {
+        [
+            &mut self._1sat,
+            &mut self._10sats,
+            &mut self._100sats,
+            &mut self._1k_sats,
+            &mut self._10k_sats,
+            &mut self._100k_sats,
+            &mut self._1m_sats,
+            &mut self._10m_sats,
+            &mut self._1btc,
+            &mut self._10btc,
+            &mut self._100btc,
+            &mut self._1k_btc,
+            &mut self._10k_btc,
+        ]
+    }
+}
+
+impl<T> ByGreatEqualAmount<(GroupFilter, T)> {
+    pub fn vecs(&self) -> [&T; 13] {
+        [
+            &self._1sat.1,
+            &self._10sats.1,
+            &self._100sats.1,
+            &self._1k_sats.1,
+            &self._10k_sats.1,
+            &self._100k_sats.1,
+            &self._1m_sats.1,
+            &self._10m_sats.1,
+            &self._1btc.1,
+            &self._10btc.1,
+            &self._100btc.1,
+            &self._1k_btc.1,
+            &self._10k_btc.1,
+        ]
+    }
+}
+
+impl<T> From<ByGreatEqualAmount<T>> for ByGreatEqualAmount<(GroupFilter, T)> {
+    fn from(value: ByGreatEqualAmount<T>) -> Self {
+        Self {
+            _1sat: (GroupFilter::GreaterOrEqual(Sats::_1.into()), value._1sat),
+            _10sats: (GroupFilter::GreaterOrEqual(Sats::_10.into()), value._10sats),
+            _100sats: (
+                GroupFilter::GreaterOrEqual(Sats::_100.into()),
+                value._100sats,
+            ),
+            _1k_sats: (
+                GroupFilter::GreaterOrEqual(Sats::_1K.into()),
+                value._1k_sats,
+            ),
+            _10k_sats: (
+                GroupFilter::GreaterOrEqual(Sats::_10K.into()),
+                value._10k_sats,
+            ),
+            _100k_sats: (
+                GroupFilter::GreaterOrEqual(Sats::_100K.into()),
+                value._100k_sats,
+            ),
+            _1m_sats: (
+                GroupFilter::GreaterOrEqual(Sats::_1M.into()),
+                value._1m_sats,
+            ),
+            _10m_sats: (
+                GroupFilter::GreaterOrEqual(Sats::_10M.into()),
+                value._10m_sats,
+            ),
+            _1btc: (GroupFilter::GreaterOrEqual(Sats::_1BTC.into()), value._1btc),
+            _10btc: (
+                GroupFilter::GreaterOrEqual(Sats::_10BTC.into()),
+                value._10btc,
+            ),
+            _100btc: (
+                GroupFilter::GreaterOrEqual(Sats::_100BTC.into()),
+                value._100btc,
+            ),
+            _1k_btc: (
+                GroupFilter::GreaterOrEqual(Sats::_1K_BTC.into()),
+                value._1k_btc,
+            ),
+            _10k_btc: (
+                GroupFilter::GreaterOrEqual(Sats::_10K_BTC.into()),
+                value._10k_btc,
+            ),
+        }
+    }
+}

crates/brk_core/src/groups/by_lt_amount.rs

@@ -0,0 +1,86 @@
+use crate::Sats;
+
+use super::GroupFilter;
+
+#[derive(Default, Clone)]
+pub struct ByLowerThanAmount<T> {
+    pub _10sats: T,
+    pub _100sats: T,
+    pub _1k_sats: T,
+    pub _10k_sats: T,
+    pub _100k_sats: T,
+    pub _1m_sats: T,
+    pub _10m_sats: T,
+    pub _1btc: T,
+    pub _10btc: T,
+    pub _100btc: T,
+    pub _1k_btc: T,
+    pub _10k_btc: T,
+    pub _100k_btc: T,
+}
+
+impl<T> ByLowerThanAmount<T> {
+    pub fn as_mut_vec(&mut self) -> [&mut T; 13] {
+        [
+            &mut self._10sats,
+            &mut self._100sats,
+            &mut self._1k_sats,
+            &mut self._10k_sats,
+            &mut self._100k_sats,
+            &mut self._1m_sats,
+            &mut self._10m_sats,
+            &mut self._1btc,
+            &mut self._10btc,
+            &mut self._100btc,
+            &mut self._1k_btc,
+            &mut self._10k_btc,
+            &mut self._100k_btc,
+        ]
+    }
+}
+
+impl<T> ByLowerThanAmount<(GroupFilter, T)> {
+    pub fn vecs(&self) -> [&T; 13] {
+        [
+            &self._10sats.1,
+            &self._100sats.1,
+            &self._1k_sats.1,
+            &self._10k_sats.1,
+            &self._100k_sats.1,
+            &self._1m_sats.1,
+            &self._10m_sats.1,
+            &self._1btc.1,
+            &self._10btc.1,
+            &self._100btc.1,
+            &self._1k_btc.1,
+            &self._10k_btc.1,
+            &self._100k_btc.1,
+        ]
+    }
+}
+
+impl<T> From<ByLowerThanAmount<T>> for ByLowerThanAmount<(GroupFilter, T)> {
+    fn from(value: ByLowerThanAmount<T>) -> Self {
+        Self {
+            _10sats: (GroupFilter::LowerThan(Sats::_10.into()), value._10sats),
+            _100sats: (GroupFilter::LowerThan(Sats::_100.into()), value._100sats),
+            _1k_sats: (GroupFilter::LowerThan(Sats::_1K.into()), value._1k_sats),
+            _10k_sats: (GroupFilter::LowerThan(Sats::_10K.into()), value._10k_sats),
+            _100k_sats: (GroupFilter::LowerThan(Sats::_100K.into()), value._100k_sats),
+            _1m_sats: (GroupFilter::LowerThan(Sats::_1M.into()), value._1m_sats),
+            _10m_sats: (GroupFilter::LowerThan(Sats::_10M.into()), value._10m_sats),
+            _1btc: (GroupFilter::LowerThan(Sats::_1BTC.into()), value._1btc),
+            _10btc: (GroupFilter::LowerThan(Sats::_10BTC.into()), value._10btc),
+            _100btc: (GroupFilter::LowerThan(Sats::_100BTC.into()), value._100btc),
+            _1k_btc: (GroupFilter::LowerThan(Sats::_1K_BTC.into()), value._1k_btc),
+            _10k_btc: (
+                GroupFilter::LowerThan(Sats::_10K_BTC.into()),
+                value._10k_btc,
+            ),
+            _100k_btc: (
+                GroupFilter::LowerThan(Sats::_100K_BTC.into()),
+                value._100k_btc,
+            ),
+        }
+    }
+}

crates/brk_core/src/groups/by_max_age.rs

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

crates/brk_core/src/groups/by_min_age.rs

@@ -0,0 +1,98 @@
+use super::GroupFilter;
+
+#[derive(Default, Clone)]
+pub struct ByMinAge<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 _12y: T,
+}
+
+impl<T> ByMinAge<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._12y,
+        ]
+    }
+}
+
+impl<T> ByMinAge<(GroupFilter, 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._12y.1,
+        ]
+    }
+}
+
+impl<T> From<ByMinAge<T>> for ByMinAge<(GroupFilter, T)> {
+    fn from(value: ByMinAge<T>) -> Self {
+        Self {
+            _1d: (GroupFilter::GreaterOrEqual(1), value._1d),
+            _1w: (GroupFilter::GreaterOrEqual(7), value._1w),
+            _1m: (GroupFilter::GreaterOrEqual(30), value._1m),
+            _2m: (GroupFilter::GreaterOrEqual(2 * 30), value._2m),
+            _3m: (GroupFilter::GreaterOrEqual(3 * 30), value._3m),
+            _4m: (GroupFilter::GreaterOrEqual(4 * 30), value._4m),
+            _5m: (GroupFilter::GreaterOrEqual(5 * 30), value._5m),
+            _6m: (GroupFilter::GreaterOrEqual(6 * 30), value._6m),
+            _1y: (GroupFilter::GreaterOrEqual(365), value._1y),
+            _2y: (GroupFilter::GreaterOrEqual(2 * 365), value._2y),
+            _3y: (GroupFilter::GreaterOrEqual(3 * 365), value._3y),
+            _4y: (GroupFilter::GreaterOrEqual(4 * 365), value._4y),
+            _5y: (GroupFilter::GreaterOrEqual(5 * 365), value._5y),
+            _6y: (GroupFilter::GreaterOrEqual(6 * 365), value._6y),
+            _7y: (GroupFilter::GreaterOrEqual(7 * 365), value._7y),
+            _8y: (GroupFilter::GreaterOrEqual(8 * 365), value._8y),
+            _10y: (GroupFilter::GreaterOrEqual(10 * 365), value._10y),
+            _12y: (GroupFilter::GreaterOrEqual(12 * 365), value._12y),
+        }
+    }
+}

crates/brk_core/src/groups/by_spendable_type.rs

@@ -1,11 +1,11 @@
 use std::ops::{Add, AddAssign};
 
-use brk_core::OutputType;
+use crate::OutputType;
 
-use super::OutputFilter;
+use super::GroupFilter;
 
 #[derive(Default, Clone, Debug)]
-pub struct OutputsBySpendableType<T> {
+pub struct BySpendableType<T> {
     pub p2pk65: T,
     pub p2pk33: T,
     pub p2pkh: T,
@@ -19,24 +19,7 @@ pub struct OutputsBySpendableType<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!(),
-    //     }
-    // }
-
+impl<T> BySpendableType<T> {
     pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
         match output_type {
             OutputType::P2PK65 => &mut self.p2pk65,
@@ -54,22 +37,6 @@ impl<T> OutputsBySpendableType<T> {
         }
     }
 
-    // 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,
@@ -103,7 +70,7 @@ impl<T> OutputsBySpendableType<T> {
     }
 }
 
-impl<T> OutputsBySpendableType<(OutputFilter, T)> {
+impl<T> BySpendableType<(GroupFilter, T)> {
     pub fn vecs(&self) -> [&T; 11] {
         [
             &self.p2pk65.1,
@@ -121,25 +88,25 @@ impl<T> OutputsBySpendableType<(OutputFilter, T)> {
     }
 }
 
-impl<T> From<OutputsBySpendableType<T>> for OutputsBySpendableType<(OutputFilter, T)> {
-    fn from(value: OutputsBySpendableType<T>) -> Self {
+impl<T> From<BySpendableType<T>> for BySpendableType<(GroupFilter, T)> {
+    fn from(value: BySpendableType<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),
+            p2pk65: (GroupFilter::Type(OutputType::P2PK65), value.p2pk65),
+            p2pk33: (GroupFilter::Type(OutputType::P2PK33), value.p2pk33),
+            p2pkh: (GroupFilter::Type(OutputType::P2PKH), value.p2pkh),
+            p2ms: (GroupFilter::Type(OutputType::P2MS), value.p2ms),
+            p2sh: (GroupFilter::Type(OutputType::P2SH), value.p2sh),
+            p2wpkh: (GroupFilter::Type(OutputType::P2WPKH), value.p2wpkh),
+            p2wsh: (GroupFilter::Type(OutputType::P2WSH), value.p2wsh),
+            p2tr: (GroupFilter::Type(OutputType::P2TR), value.p2tr),
+            p2a: (GroupFilter::Type(OutputType::P2A), value.p2a),
+            unknown: (GroupFilter::Type(OutputType::Unknown), value.unknown),
+            empty: (GroupFilter::Type(OutputType::Empty), value.empty),
         }
     }
 }
 
-impl<T> Add for OutputsBySpendableType<T>
+impl<T> Add for BySpendableType<T>
 where
     T: Add<Output = T>,
 {
@@ -161,7 +128,7 @@ where
     }
 }
 
-impl<T> AddAssign for OutputsBySpendableType<T>
+impl<T> AddAssign for BySpendableType<T>
 where
     T: AddAssign,
 {

crates/brk_core/src/groups/by_term.rs

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

crates/brk_core/src/groups/by_type.rs

@@ -1,16 +1,16 @@
 use std::ops::{Add, AddAssign};
 
-use brk_core::OutputType;
+use crate::OutputType;
 
-use super::{OutputsBySpendableType, OutputsByUnspendableType};
+use super::{BySpendableType, ByUnspendableType};
 
 #[derive(Default, Clone, Debug)]
-pub struct OutputsByType<T> {
-    pub spendable: OutputsBySpendableType<T>,
-    pub unspendable: OutputsByUnspendableType<T>,
+pub struct GroupedByType<T> {
+    pub spendable: BySpendableType<T>,
+    pub unspendable: ByUnspendableType<T>,
 }
 
-impl<T> OutputsByType<T> {
+impl<T> GroupedByType<T> {
     pub fn get(&self, output_type: OutputType) -> &T {
         match output_type {
             OutputType::P2PK65 => &self.spendable.p2pk65,
@@ -44,25 +44,9 @@ impl<T> OutputsByType<T> {
             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>
+impl<T> Add for GroupedByType<T>
 where
     T: Add<Output = T>,
 {
@@ -75,7 +59,7 @@ where
     }
 }
 
-impl<T> AddAssign for OutputsByType<T>
+impl<T> AddAssign for GroupedByType<T>
 where
     T: AddAssign,
 {

crates/brk_core/src/groups/by_unspendable_type.rs

@@ -1,17 +1,17 @@
 use std::ops::{Add, AddAssign};
 
 #[derive(Default, Clone, Debug)]
-pub struct OutputsByUnspendableType<T> {
+pub struct ByUnspendableType<T> {
     pub opreturn: T,
 }
 
-impl<T> OutputsByUnspendableType<T> {
+impl<T> ByUnspendableType<T> {
     pub fn as_vec(&self) -> [&T; 1] {
         [&self.opreturn]
     }
 }
 
-impl<T> Add for OutputsByUnspendableType<T>
+impl<T> Add for ByUnspendableType<T>
 where
     T: Add<Output = T>,
 {
@@ -23,7 +23,7 @@ where
     }
 }
 
-impl<T> AddAssign for OutputsByUnspendableType<T>
+impl<T> AddAssign for ByUnspendableType<T>
 where
     T: AddAssign,
 {

crates/brk_core/src/groups/by_value.rs

@@ -1,5 +1,5 @@
 #[derive(Default, Clone)]
-pub struct OutputsByValue<T> {
+pub struct GroupedByValue<T> {
     pub up_to_1cent: T,
     pub from_1c_to_10c: T,
     pub from_10c_to_1d: T,
@@ -16,7 +16,7 @@ pub struct OutputsByValue<T> {
     // ...
 }
 
-impl<T> OutputsByValue<T> {
+impl<T> GroupedByValue<T> {
     pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
         vec![
             &mut self.up_to_1cent,

crates/brk_core/src/groups/filter.rs

@@ -0,0 +1,51 @@
+use std::ops::Range;
+
+use crate::{HalvingEpoch, OutputType};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum GroupFilter {
+    All,
+    LowerThan(usize),
+    Range(Range<usize>),
+    GreaterOrEqual(usize),
+    Epoch(HalvingEpoch),
+    Type(OutputType),
+}
+
+impl GroupFilter {
+    pub fn contains(&self, value: usize) -> bool {
+        match self {
+            GroupFilter::All => true,
+            GroupFilter::LowerThan(max) => *max > value,
+            GroupFilter::GreaterOrEqual(min) => *min <= value,
+            GroupFilter::Range(r) => r.contains(&value),
+            GroupFilter::Epoch(_) => false,
+            GroupFilter::Type(_) => false,
+        }
+    }
+
+    pub fn includes(&self, other: &GroupFilter) -> bool {
+        match self {
+            GroupFilter::All => true,
+            GroupFilter::LowerThan(max) => match other {
+                GroupFilter::All => false,
+                GroupFilter::LowerThan(max2) => max >= max2,
+                GroupFilter::Range(range) => range.end <= *max,
+                GroupFilter::GreaterOrEqual(_) => false,
+                GroupFilter::Epoch(_) => false,
+                GroupFilter::Type(_) => false,
+            },
+            GroupFilter::GreaterOrEqual(min) => match other {
+                GroupFilter::All => false,
+                GroupFilter::LowerThan(_) => false,
+                GroupFilter::Range(range) => range.start >= *min,
+                GroupFilter::GreaterOrEqual(min2) => min <= min2,
+                GroupFilter::Epoch(_) => false,
+                GroupFilter::Type(_) => false,
+            },
+            GroupFilter::Range(_) => false,
+            GroupFilter::Epoch(_) => false,
+            GroupFilter::Type(_) => false,
+        }
+    }
+}

crates/brk_core/src/groups/mod.rs

@@ -0,0 +1,31 @@
+mod address;
+mod by_address_type;
+mod by_age_range;
+mod by_amount_range;
+mod by_epoch;
+mod by_ge_amount;
+mod by_lt_amount;
+mod by_max_age;
+mod by_min_age;
+mod by_spendable_type;
+mod by_term;
+mod by_type;
+mod by_unspendable_type;
+mod filter;
+mod utxo;
+
+pub use address::*;
+pub use by_address_type::*;
+pub use by_age_range::*;
+pub use by_amount_range::*;
+pub use by_epoch::*;
+pub use by_ge_amount::*;
+pub use by_lt_amount::*;
+pub use by_max_age::*;
+pub use by_min_age::*;
+pub use by_spendable_type::*;
+pub use by_term::*;
+pub use by_type::*;
+pub use by_unspendable_type::*;
+pub use filter::*;
+pub use utxo::*;

crates/brk_core/src/groups/utxo.rs

@@ -0,0 +1,90 @@
+use crate::{
+    ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge, ByMinAge,
+    BySpendableType, ByTerm, GroupFilter,
+};
+
+#[derive(Default, Clone)]
+pub struct UTXOGroups<T> {
+    pub all: T,
+    pub age_range: ByAgeRange<T>,
+    pub epoch: ByEpoch<T>,
+    pub min_age: ByMinAge<T>,
+    pub ge_amount: ByGreatEqualAmount<T>,
+    pub amount_range: ByAmountRange<T>,
+    pub term: ByTerm<T>,
+    pub _type: BySpendableType<T>,
+    pub max_age: ByMaxAge<T>,
+    pub lt_amount: ByLowerThanAmount<T>,
+}
+
+impl<T> UTXOGroups<T> {
+    pub fn as_mut_vecs(&mut self) -> Vec<&mut T> {
+        [&mut self.all]
+            .into_iter()
+            .chain(self.term.as_mut_vec())
+            .chain(self.max_age.as_mut_vec())
+            .chain(self.min_age.as_mut_vec())
+            .chain(self.ge_amount.as_mut_vec())
+            .chain(self.age_range.as_mut_vec())
+            .chain(self.epoch.as_mut_vec())
+            .chain(self.amount_range.as_mut_vec())
+            .chain(self.lt_amount.as_mut_vec())
+            .chain(self._type.as_mut_vec())
+            .collect::<Vec<_>>()
+    }
+
+    pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> {
+        self.age_range
+            .as_mut_vec()
+            .into_iter()
+            .chain(self.epoch.as_mut_vec())
+            .chain(self.amount_range.as_mut_vec())
+            .chain(self._type.as_mut_vec())
+            .collect::<Vec<_>>()
+    }
+
+    pub fn as_mut_overlapping_vecs(&mut self) -> Vec<&mut T> {
+        [&mut self.all]
+            .into_iter()
+            .chain(self.term.as_mut_vec())
+            .chain(self.max_age.as_mut_vec())
+            .chain(self.min_age.as_mut_vec())
+            .chain(self.lt_amount.as_mut_vec())
+            .chain(self.ge_amount.as_mut_vec())
+            .collect::<Vec<_>>()
+    }
+}
+
+impl<T> UTXOGroups<(GroupFilter, T)> {
+    pub fn vecs(&self) -> Vec<&T> {
+        [&self.all.1]
+            .into_iter()
+            .chain(self.term.vecs())
+            .chain(self.max_age.vecs())
+            .chain(self.min_age.vecs())
+            .chain(self.age_range.vecs())
+            .chain(self.epoch.vecs())
+            .chain(self.amount_range.vecs())
+            .chain(self._type.vecs())
+            .chain(self.lt_amount.vecs())
+            .chain(self.ge_amount.vecs())
+            .collect::<Vec<_>>()
+    }
+}
+
+impl<T> From<UTXOGroups<T>> for UTXOGroups<(GroupFilter, T)> {
+    fn from(value: UTXOGroups<T>) -> Self {
+        Self {
+            all: (GroupFilter::All, value.all),
+            term: ByTerm::from(value.term),
+            max_age: ByMaxAge::from(value.max_age),
+            min_age: ByMinAge::from(value.min_age),
+            age_range: ByAgeRange::from(value.age_range),
+            epoch: ByEpoch::from(value.epoch),
+            amount_range: ByAmountRange::from(value.amount_range),
+            lt_amount: ByLowerThanAmount::from(value.lt_amount),
+            ge_amount: ByGreatEqualAmount::from(value.ge_amount),
+            _type: BySpendableType::from(value._type),
+        }
+    }
+}

crates/brk_core/src/lib.rs

@@ -1,11 +1,13 @@
 #![doc = include_str!("../README.md")]
 
-mod enums;
+mod error;
+mod groups;
 mod structs;
 mod traits;
 mod utils;
 
-pub use enums::*;
+pub use error::*;
+pub use groups::*;
 pub use structs::*;
 pub use traits::*;
 pub use utils::*;

crates/brk_core/src/structs/addressbytes.rs

@@ -162,7 +162,7 @@ impl fmt::Display for P2PKHBytes {
             .push_opcode(opcodes::all::OP_CHECKSIG)
             .into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
-        write!(f, "{}", address)
+        write!(f, "{address}")
     }
 }
 
@@ -192,7 +192,7 @@ impl fmt::Display for P2SHBytes {
             .push_opcode(opcodes::all::OP_EQUAL)
             .into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
-        write!(f, "{}", address)
+        write!(f, "{address}")
     }
 }
 
@@ -218,7 +218,7 @@ impl fmt::Display for P2WPKHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(0).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
-        write!(f, "{}", address)
+        write!(f, "{address}")
     }
 }
 
@@ -244,7 +244,7 @@ impl fmt::Display for P2WSHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(0).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
-        write!(f, "{}", address)
+        write!(f, "{address}")
     }
 }
 
@@ -270,7 +270,7 @@ impl fmt::Display for P2TRBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(1).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
-        write!(f, "{}", address)
+        write!(f, "{address}")
     }
 }
 
@@ -296,7 +296,7 @@ impl fmt::Display for P2ABytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(1).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
-        write!(f, "{}", address)
+        write!(f, "{address}")
     }
 }
 

crates/brk_core/src/structs/addressdata.rs

@@ -0,0 +1,102 @@
+use byteview::ByteView;
+use zerocopy::{FromBytes, IntoBytes};
+
+use crate::{Bitcoin, CheckedSub, Dollars, EmptyAddressData, Error, Result, Sats};
+
+#[derive(Debug, Default, Clone)]
+#[repr(C)]
+pub struct AddressData {
+    pub sent: Sats,
+    pub received: Sats,
+    pub realized_cap: Dollars,
+    pub outputs_len: u32,
+}
+
+impl AddressData {
+    pub fn amount(&self) -> Sats {
+        (u64::from(self.received) - u64::from(self.sent)).into()
+    }
+
+    pub fn realized_price(&self) -> Dollars {
+        (self.realized_cap / Bitcoin::from(self.amount())).round_nearest_cent()
+    }
+
+    #[inline(always)]
+    pub fn has_0_sats(&self) -> bool {
+        self.amount() == Sats::ZERO
+    }
+
+    #[inline(always)]
+    pub fn has_0_utxos(&self) -> bool {
+        self.outputs_len == 0
+    }
+
+    pub fn receive(&mut self, amount: Sats, price: Option<Dollars>) {
+        self.received += amount;
+        self.outputs_len += 1;
+        if let Some(price) = price {
+            self.realized_cap += price * amount;
+        }
+    }
+
+    pub fn send(&mut self, amount: Sats, previous_price: Option<Dollars>) -> Result<()> {
+        if self.amount() < amount {
+            return Err(Error::String("Previous_amount smaller than sent amount"));
+        }
+        self.sent += amount;
+        self.outputs_len -= 1;
+        if let Some(previous_price) = previous_price {
+            self.realized_cap = self
+                .realized_cap
+                .checked_sub(previous_price * amount)
+                .unwrap();
+        }
+        Ok(())
+    }
+}
+
+impl From<EmptyAddressData> for AddressData {
+    fn from(value: EmptyAddressData) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&EmptyAddressData> for AddressData {
+    fn from(value: &EmptyAddressData) -> Self {
+        Self {
+            sent: value.transfered,
+            received: value.transfered,
+            realized_cap: Dollars::ZERO,
+            outputs_len: 0,
+        }
+    }
+}
+
+impl From<ByteView> for AddressData {
+    fn from(value: ByteView) -> Self {
+        Self {
+            // MUST be same order as impl From<&AddressData> for ByteView
+            sent: Sats::read_from_bytes(&value[..8]).unwrap(),
+            received: Sats::read_from_bytes(&value[8..16]).unwrap(),
+            realized_cap: Dollars::read_from_bytes(&value[16..24]).unwrap(),
+            outputs_len: u32::read_from_bytes(&value[24..]).unwrap(),
+        }
+    }
+}
+impl From<AddressData> for ByteView {
+    fn from(value: AddressData) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&AddressData> for ByteView {
+    fn from(value: &AddressData) -> Self {
+        Self::new(
+            &[
+                value.sent.as_bytes(),
+                value.received.as_bytes(),
+                value.realized_cap.as_bytes(),
+                value.outputs_len.as_bytes(),
+            ]
+            .concat(),
+        )
+    }
+}

crates/brk_core/src/structs/dollars.rs

@@ -38,6 +38,10 @@ impl Dollars {
     pub const fn mint(dollars: f64) -> Self {
         Self(dollars)
     }
+
+    pub fn round_nearest_cent(self) -> Self {
+        Dollars((self.0 * 100.0).round() / 100.0)
+    }
 }
 
 impl From<f32> for Dollars {

crates/brk_core/src/structs/emptyaddressdata.rs

@@ -0,0 +1,44 @@
+use byteview::ByteView;
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{AddressData, Sats};
+
+#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
+pub struct EmptyAddressData {
+    pub transfered: Sats,
+}
+
+impl From<AddressData> for EmptyAddressData {
+    fn from(value: AddressData) -> Self {
+        Self::from(&value)
+    }
+}
+
+impl From<&AddressData> for EmptyAddressData {
+    fn from(value: &AddressData) -> Self {
+        if value.sent != value.received {
+            dbg!(&value);
+            panic!("Trying to convert not empty wallet to empty !");
+        }
+        Self {
+            transfered: value.sent,
+        }
+    }
+}
+
+impl From<ByteView> for EmptyAddressData {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<EmptyAddressData> for ByteView {
+    fn from(value: EmptyAddressData) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&EmptyAddressData> for ByteView {
+    fn from(value: &EmptyAddressData) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/mod.rs

@@ -1,5 +1,6 @@
 mod addressbytes;
 mod addressbyteshash;
+mod addressdata;
 mod bitcoin;
 mod blockhash;
 mod blockhashprefix;
@@ -9,6 +10,7 @@ mod dateindex;
 mod decadeindex;
 mod difficultyepoch;
 mod dollars;
+mod emptyaddressdata;
 mod emptyoutputindex;
 mod feerate;
 mod halvingepoch;
@@ -43,6 +45,7 @@ mod txidprefix;
 mod txindex;
 mod txversion;
 mod typeindex;
+mod typeindex_with_outputindex;
 mod unit;
 mod unknownoutputindex;
 mod version;
@@ -54,6 +57,7 @@ mod yearindex;
 
 pub use addressbytes::*;
 pub use addressbyteshash::*;
+pub use addressdata::*;
 pub use bitcoin::*;
 pub use blockhash::*;
 pub use blockhashprefix::*;
@@ -63,6 +67,7 @@ pub use dateindex::*;
 pub use decadeindex::*;
 pub use difficultyepoch::*;
 pub use dollars::*;
+pub use emptyaddressdata::*;
 pub use emptyoutputindex::*;
 pub use feerate::*;
 pub use halvingepoch::*;
@@ -97,6 +102,7 @@ pub use txidprefix::*;
 pub use txindex::*;
 pub use txversion::*;
 pub use typeindex::*;
+pub use typeindex_with_outputindex::*;
 pub use unit::*;
 pub use unknownoutputindex::*;
 pub use version::*;

crates/brk_core/src/structs/outputindex.rs

@@ -28,6 +28,8 @@ use super::Vout;
 pub struct OutputIndex(u64);
 
 impl OutputIndex {
+    pub const ZERO: Self = Self(0);
+
     pub const COINBASE: Self = Self(u64::MAX);
 
     pub fn incremented(self) -> Self {

crates/brk_core/src/structs/outputtype.rs

@@ -50,6 +50,27 @@ impl OutputType {
         }
     }
 
+    pub fn is_address(&self) -> bool {
+        match self {
+            Self::P2PK65 => true,
+            Self::P2PK33 => true,
+            Self::P2PKH => true,
+            Self::P2MS => false,
+            Self::P2SH => true,
+            Self::OpReturn => false,
+            Self::P2WPKH => true,
+            Self::P2WSH => true,
+            Self::P2TR => true,
+            Self::P2A => true,
+            Self::Empty => false,
+            Self::Unknown => false,
+        }
+    }
+
+    pub fn is_not_address(&self) -> bool {
+        !self.is_address()
+    }
+
     pub fn is_unspendable(&self) -> bool {
         !self.is_spendable()
     }

crates/brk_core/src/structs/p2aaddressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,6 +31,21 @@ impl From<TypeIndex> for P2AAddressIndex {
         Self(value)
     }
 }
+impl From<P2AAddressIndex> for TypeIndex {
+    fn from(value: P2AAddressIndex) -> Self {
+        value.0
+    }
+}
+impl From<P2AAddressIndex> for u32 {
+    fn from(value: P2AAddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2AAddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<P2AAddressIndex> for usize {
     fn from(value: P2AAddressIndex) -> Self {
         Self::from(*value)
@@ -59,3 +76,19 @@ impl Printable for P2AAddressIndex {
         &["aaddr", "p2aaddr", "p2aaddressindex"]
     }
 }
+
+impl From<ByteView> for P2AAddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2AAddressIndex> for ByteView {
+    fn from(value: P2AAddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2AAddressIndex> for ByteView {
+    fn from(value: &P2AAddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/p2pk33addressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,6 +31,21 @@ impl From<TypeIndex> for P2PK33AddressIndex {
         Self(value)
     }
 }
+impl From<P2PK33AddressIndex> for TypeIndex {
+    fn from(value: P2PK33AddressIndex) -> Self {
+        value.0
+    }
+}
+impl From<P2PK33AddressIndex> for u32 {
+    fn from(value: P2PK33AddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2PK33AddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<P2PK33AddressIndex> for usize {
     fn from(value: P2PK33AddressIndex) -> Self {
         Self::from(*value)
@@ -60,3 +77,19 @@ impl Printable for P2PK33AddressIndex {
         &["pk33addr", "p2pk33addr", "p2pk33addressindex"]
     }
 }
+
+impl From<ByteView> for P2PK33AddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2PK33AddressIndex> for ByteView {
+    fn from(value: P2PK33AddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2PK33AddressIndex> for ByteView {
+    fn from(value: &P2PK33AddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/p2pk65addressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,11 +31,26 @@ impl From<TypeIndex> for P2PK65AddressIndex {
         Self(value)
     }
 }
+impl From<P2PK65AddressIndex> for TypeIndex {
+    fn from(value: P2PK65AddressIndex) -> Self {
+        value.0
+    }
+}
 impl From<P2PK65AddressIndex> for usize {
     fn from(value: P2PK65AddressIndex) -> Self {
         Self::from(*value)
     }
 }
+impl From<P2PK65AddressIndex> for u32 {
+    fn from(value: P2PK65AddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2PK65AddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<usize> for P2PK65AddressIndex {
     fn from(value: usize) -> Self {
         Self(TypeIndex::from(value))
@@ -59,3 +76,19 @@ impl Printable for P2PK65AddressIndex {
         &["pk65addr", "p2pk65addr", "p2pk65addressindex"]
     }
 }
+
+impl From<ByteView> for P2PK65AddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2PK65AddressIndex> for ByteView {
+    fn from(value: P2PK65AddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2PK65AddressIndex> for ByteView {
+    fn from(value: &P2PK65AddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/p2pkhaddressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,11 +31,26 @@ impl From<TypeIndex> for P2PKHAddressIndex {
         Self(value)
     }
 }
+impl From<P2PKHAddressIndex> for TypeIndex {
+    fn from(value: P2PKHAddressIndex) -> Self {
+        value.0
+    }
+}
 impl From<P2PKHAddressIndex> for usize {
     fn from(value: P2PKHAddressIndex) -> Self {
         Self::from(*value)
     }
 }
+impl From<P2PKHAddressIndex> for u32 {
+    fn from(value: P2PKHAddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2PKHAddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<usize> for P2PKHAddressIndex {
     fn from(value: usize) -> Self {
         Self(TypeIndex::from(value))
@@ -60,3 +77,19 @@ impl Printable for P2PKHAddressIndex {
         &["pkhaddr", "p2pkhaddr", "p2pkhaddressindex"]
     }
 }
+
+impl From<ByteView> for P2PKHAddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2PKHAddressIndex> for ByteView {
+    fn from(value: P2PKHAddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2PKHAddressIndex> for ByteView {
+    fn from(value: &P2PKHAddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/p2shaddressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,6 +31,21 @@ impl From<TypeIndex> for P2SHAddressIndex {
         Self(value)
     }
 }
+impl From<P2SHAddressIndex> for TypeIndex {
+    fn from(value: P2SHAddressIndex) -> Self {
+        value.0
+    }
+}
+impl From<P2SHAddressIndex> for u32 {
+    fn from(value: P2SHAddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2SHAddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<P2SHAddressIndex> for usize {
     fn from(value: P2SHAddressIndex) -> Self {
         Self::from(*value)
@@ -60,3 +77,19 @@ impl Printable for P2SHAddressIndex {
         &["shaddr", "p2shaddr", "p2shaddressindex"]
     }
 }
+
+impl From<ByteView> for P2SHAddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2SHAddressIndex> for ByteView {
+    fn from(value: P2SHAddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2SHAddressIndex> for ByteView {
+    fn from(value: &P2SHAddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/p2traddressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,6 +31,21 @@ impl From<TypeIndex> for P2TRAddressIndex {
         Self(value)
     }
 }
+impl From<P2TRAddressIndex> for TypeIndex {
+    fn from(value: P2TRAddressIndex) -> Self {
+        value.0
+    }
+}
+impl From<P2TRAddressIndex> for u32 {
+    fn from(value: P2TRAddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2TRAddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<P2TRAddressIndex> for usize {
     fn from(value: P2TRAddressIndex) -> Self {
         Self::from(*value)
@@ -60,3 +77,19 @@ impl Printable for P2TRAddressIndex {
         &["traddr", "p2traddr", "p2traddressindex"]
     }
 }
+
+impl From<ByteView> for P2TRAddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2TRAddressIndex> for ByteView {
+    fn from(value: P2TRAddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2TRAddressIndex> for ByteView {
+    fn from(value: &P2TRAddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/p2wpkhaddressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,11 +31,26 @@ impl From<TypeIndex> for P2WPKHAddressIndex {
         Self(value)
     }
 }
+impl From<P2WPKHAddressIndex> for TypeIndex {
+    fn from(value: P2WPKHAddressIndex) -> Self {
+        value.0
+    }
+}
 impl From<P2WPKHAddressIndex> for usize {
     fn from(value: P2WPKHAddressIndex) -> Self {
         Self::from(*value)
     }
 }
+impl From<P2WPKHAddressIndex> for u32 {
+    fn from(value: P2WPKHAddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2WPKHAddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<usize> for P2WPKHAddressIndex {
     fn from(value: usize) -> Self {
         Self(TypeIndex::from(value))
@@ -60,3 +77,19 @@ impl Printable for P2WPKHAddressIndex {
         &["wpkhaddr", "p2wpkhaddr", "p2wpkhaddressindex"]
     }
 }
+
+impl From<ByteView> for P2WPKHAddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2WPKHAddressIndex> for ByteView {
+    fn from(value: P2WPKHAddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2WPKHAddressIndex> for ByteView {
+    fn from(value: &P2WPKHAddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/p2wshaddressindex.rs

@@ -1,7 +1,9 @@
 use std::ops::Add;
 
+use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Printable, TypeIndex};
@@ -29,6 +31,21 @@ impl From<TypeIndex> for P2WSHAddressIndex {
         Self(value)
     }
 }
+impl From<P2WSHAddressIndex> for TypeIndex {
+    fn from(value: P2WSHAddressIndex) -> Self {
+        value.0
+    }
+}
+impl From<P2WSHAddressIndex> for u32 {
+    fn from(value: P2WSHAddressIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<u32> for P2WSHAddressIndex {
+    fn from(value: u32) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
 impl From<P2WSHAddressIndex> for usize {
     fn from(value: P2WSHAddressIndex) -> Self {
         Self::from(*value)
@@ -60,3 +77,19 @@ impl Printable for P2WSHAddressIndex {
         &["wshaddr", "p2wshaddr", "p2wshaddressindex"]
     }
 }
+
+impl From<ByteView> for P2WSHAddressIndex {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
+    }
+}
+impl From<P2WSHAddressIndex> for ByteView {
+    fn from(value: P2WSHAddressIndex) -> Self {
+        Self::from(&value)
+    }
+}
+impl From<&P2WSHAddressIndex> for ByteView {
+    fn from(value: &P2WSHAddressIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/sats.rs

@@ -36,8 +36,22 @@ pub struct Sats(u64);
 #[allow(clippy::inconsistent_digit_grouping)]
 impl Sats {
     pub const ZERO: Self = Self(0);
-    pub const MAX: Self = Self(u64::MAX);
+    pub const _1: Self = Self(1);
+    pub const _10: Self = Self(10);
+    pub const _100: Self = Self(100);
+    pub const _1K: Self = Self(1_000);
+    pub const _10K: Self = Self(10_000);
+    pub const _100K: Self = Self(100_000);
+    pub const _1M: Self = Self(1_000_000);
+    pub const _10M: Self = Self(10_000_000);
+    pub const _1BTC: Self = Self::ONE_BTC;
+    pub const _10BTC: Self = Self(10_00_000_000);
+    pub const _100BTC: Self = Self(100_00_000_000);
+    pub const _1K_BTC: Self = Self(1_000_00_000_000);
+    pub const _10K_BTC: Self = Self(10_000_00_000_000);
+    pub const _100K_BTC: Self = Self(100_000_00_000_000);
     pub const ONE_BTC: Self = Self(1_00_000_000);
+    pub const MAX: Self = Self(u64::MAX);
     pub const FIFTY_BTC: Self = Self(50_00_000_000);
 
     pub fn new(sats: u64) -> Self {
@@ -81,6 +95,10 @@ impl CheckedSub<usize> for Sats {
 impl SubAssign for Sats {
     fn sub_assign(&mut self, rhs: Self) {
         *self = self.checked_sub(rhs).unwrap();
+        //     .unwrap_or_else(|| {
+        //     dbg!((*self, rhs));
+        //     unreachable!();
+        // });
     }
 }
 

crates/brk_core/src/structs/stored_usize.rs

@@ -45,6 +45,11 @@ impl From<usize> for StoredUsize {
         Self(value)
     }
 }
+impl From<StoredUsize> for usize {
+    fn from(value: StoredUsize) -> Self {
+        *value
+    }
+}
 
 impl CheckedSub<StoredUsize> for StoredUsize {
     fn checked_sub(self, rhs: Self) -> Option<Self> {

crates/brk_core/src/structs/timestamp.rs

@@ -75,6 +75,10 @@ impl Timestamp {
             }
         }
     }
+
+    pub fn is_more_than_hour(&self) -> bool {
+        jiff::Timestamp::from(*self).as_second() >= 60 * 60
+    }
 }
 
 impl From<u32> for Timestamp {

crates/brk_core/src/structs/typeindex.rs

@@ -45,6 +45,11 @@ impl From<u32> for TypeIndex {
         Self(value)
     }
 }
+impl From<TypeIndex> for u32 {
+    fn from(value: TypeIndex) -> Self {
+        value.0
+    }
+}
 
 impl From<u64> for TypeIndex {
     fn from(value: u64) -> Self {

crates/brk_core/src/structs/typeindex_with_outputindex.rs

@@ -0,0 +1,48 @@
+use byteview::ByteView;
+use serde::Serialize;
+
+use crate::{TypeIndex, copy_first_4bytes, copy_first_8bytes};
+
+use super::OutputIndex;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Serialize)]
+pub struct TypeIndexWithOutputindex {
+    typeindex: TypeIndex,
+    outputindex: OutputIndex,
+}
+
+impl From<(TypeIndex, OutputIndex)> for TypeIndexWithOutputindex {
+    fn from(value: (TypeIndex, OutputIndex)) -> Self {
+        Self {
+            typeindex: value.0,
+            outputindex: value.1,
+        }
+    }
+}
+
+impl From<ByteView> for TypeIndexWithOutputindex {
+    fn from(value: ByteView) -> Self {
+        let typeindex = TypeIndex::from(u32::from_be_bytes(copy_first_4bytes(&value).unwrap()));
+        let outputindex = OutputIndex::from(u64::from_be_bytes(copy_first_8bytes(&value).unwrap()));
+        Self {
+            typeindex,
+            outputindex,
+        }
+    }
+}
+impl From<TypeIndexWithOutputindex> for ByteView {
+    fn from(value: TypeIndexWithOutputindex) -> Self {
+        ByteView::from(&value)
+    }
+}
+impl From<&TypeIndexWithOutputindex> for ByteView {
+    fn from(value: &TypeIndexWithOutputindex) -> Self {
+        ByteView::from(
+            [
+                u32::from(value.typeindex).to_be_bytes().as_slice(),
+                u64::from(value.outputindex).to_be_bytes().as_slice(),
+            ]
+            .concat(),
+        )
+    }
+}

crates/brk_core/src/utils/bytes.rs

@@ -1,5 +1,18 @@
 use crate::{Error, Result};
 
+#[allow(clippy::result_unit_err)]
+pub fn copy_first_4bytes(slice: &[u8]) -> Result<[u8; 4]> {
+    let mut buf: [u8; 4] = [0; 4];
+    let buf_len = buf.len();
+    if slice.len() < buf_len {
+        return Err(Error::String("Buffer is too small to convert to 8 bytes"));
+    }
+    slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
+        buf[i] = *r;
+    });
+    Ok(buf)
+}
+
 #[allow(clippy::result_unit_err)]
 pub fn copy_first_8bytes(slice: &[u8]) -> Result<[u8; 8]> {
     let mut buf: [u8; 8] = [0; 8];

crates/brk_fetcher/src/binance.rs

@@ -11,7 +11,7 @@ use color_eyre::eyre::{ContextCompat, eyre};
 use log::info;
 use serde_json::Value;
 
-use crate::{Close, Date, Dollars, Fetcher, High, Low, Open, fetchers::retry};
+use crate::{Close, Date, Dollars, Fetcher, High, Low, Open, retry};
 
 #[derive(Clone)]
 pub struct Binance {

crates/brk_fetcher/src/brk.rs

@@ -5,9 +5,10 @@ use color_eyre::eyre::{ContextCompat, eyre};
 use log::info;
 use serde_json::Value;
 
-use crate::{Close, Dollars, High, Low, Open, fetchers::retry};
+use crate::{Close, Dollars, High, Low, Open, retry};
 
 #[derive(Default, Clone)]
+#[allow(clippy::upper_case_acronyms)]
 pub struct BRK {
     height_to_ohlc: BTreeMap<Height, Vec<OHLCCents>>,
     dateindex_to_ohlc: BTreeMap<DateIndex, Vec<OHLCCents>>,
@@ -47,7 +48,7 @@ impl BRK {
         retry(
             |_| {
                 let url = format!(
-                    "{API_URL}/query?index=height&values=ohlc&from={}&to={}",
+                    "{API_URL}/height-to-ohlc?from={}&to={}",
                     height,
                     height + CHUNK_SIZE
                 );
@@ -96,7 +97,7 @@ impl BRK {
         retry(
             |_| {
                 let url = format!(
-                    "{API_URL}/query?index=dateindex&values=ohlc&from={}&to={}",
+                    "{API_URL}/dateindex-to-ohlc?from={}&to={}",
                     dateindex,
                     dateindex + CHUNK_SIZE
                 );

crates/brk_fetcher/src/fetchers/mod.rs

@@ -1,9 +0,0 @@
-mod binance;
-mod brk;
-mod kraken;
-mod retry;
-
-pub use binance::*;
-pub use brk::*;
-pub use kraken::*;
-use retry::*;

crates/brk_fetcher/src/kraken.rs

@@ -5,7 +5,7 @@ use color_eyre::eyre::ContextCompat;
 use log::info;
 use serde_json::Value;
 
-use crate::{Fetcher, fetchers::retry};
+use crate::{Fetcher, retry};
 
 #[derive(Default, Clone)]
 pub struct Kraken {

crates/brk_fetcher/src/lib.rs

@@ -7,12 +7,18 @@ use std::{collections::BTreeMap, path::Path, thread::sleep, time::Duration};
 
 use brk_core::{Close, Date, Dollars, Height, High, Low, OHLCCents, Open, Timestamp};
 use color_eyre::eyre::Error;
-
-mod fetchers;
-
-pub use fetchers::*;
 use log::info;
 
+mod binance;
+mod brk;
+mod kraken;
+mod retry;
+
+pub use binance::*;
+pub use brk::*;
+pub use kraken::*;
+use retry::*;
+
 const TRIES: usize = 12 * 60;
 
 #[derive(Clone)]