release: v0.0.73

website: make panes the same size + remove saving their height
packages: add lightweight-charts v5.0.8
2026-06-22 12:23:04 -07:00 · 2025-07-09 08:36:29 +02:00 · 2025-07-09 00:06:38 +02:00 · 2025-07-08 23:37:06 +02:00 · 2025-07-08 22:35:16 +02:00 · 2025-07-08 22:34:51 +02:00
399 changed files with 27708 additions and 26174 deletions
@@ -3,6 +3,8 @@

 # Builds
 target
+dist
+vecid-to-indexes.js

 # Copies
 *\ copy*
@@ -1,15 +1,17 @@
 <!--
 # v0.X.Y | WIP
-![Image of the kibo Web App version 0.X.Y](https://github.com/kibo-money/kibo/blob/main/_assets/v0.X.Y.jpg)
+![Image of the kibo Web App version 0.X.Y](https://github.com/bitcoinresearchkit/brk/blob/main/assets/v0.X.Y.jpg)
 -->

 # v0.X.0 | WIP | A new beginning

+![Image of BRK's Web App version 0.1.0](https://github.com/bitcoinresearchkit/brk/blob/main/assets/brk-v0.1.0.png)
+
 Full rewrite

-# [kibo-v0.5.0](https://github.com/kibo-money/kibo/tree/eea56d394bf92c62c81da8b78b8c47ea730683f5) | [873199](https://mempool.space/block/0000000000000000000270925aa6a565be92e13164565a3f7994ca1966e48050) - 2024/12/04
+# [kibo-v0.5.0](https://github.com/bitcoinresearchkit/brk/tree/eea56d394bf92c62c81da8b78b8c47ea730683f5) | [873199](https://mempool.space/block/0000000000000000000270925aa6a565be92e13164565a3f7994ca1966e48050) - 2024/12/04

-![Image of the kibo Web App version 0.5.0](https://github.com/kibo-money/kibo/blob/main/_assets/v0.5.0.jpg)
+![Image of the kibo Web App version 0.5.0](https://github.com/bitcoinresearchkit/brk/blob/main/assets/kibo-v0.5.0.jpg)

 ## Datasets

@@ -74,9 +76,9 @@ Full rewrite

 - Moved back to this repo

-# [kibo-v0.4.0](https://github.com/kibo-money/kibo/tree/a64c544815d9ef785e2fc1323582f774f16b9200) | [861950](https://mempool.space/block/00000000000000000000530d0e30ccf7deeace122dcc99f2668a06c6dad83629) - 2024/09/19
+# [kibo-v0.4.0](https://github.com/bitcoinresearchkit/brk/tree/a64c544815d9ef785e2fc1323582f774f16b9200) | [861950](https://mempool.space/block/00000000000000000000530d0e30ccf7deeace122dcc99f2668a06c6dad83629) - 2024/09/19

-![Image of the kibo Web App version 0.4.0](https://github.com/kibo-money/kibo/blob/main/_assets/v0.4.0.jpg)
+![Image of the kibo Web App version 0.4.0](https://github.com/bitcoinresearchkit/brk/blob/main/assets/kibo-v0.4.0.jpg)

 ## Brand

@@ -111,9 +113,9 @@ Full rewrite
 - Added serving of the website
 - Improved `Cache-Control` behavior

-# [kibo-v0.3.0](https://github.com/kibo-money/kibo/tree/b68b016091c45b071218fba01bac5b76e8eaf18c) | [853930](https://mempool.space/block/00000000000000000002eb5e9a7950ca2d5d98bd1ed28fc9098aa630d417985d) - 2024/07/26
+# [satonomics-v0.3.0](https://github.com/bitcoinresearchkit/brk/tree/b68b016091c45b071218fba01bac5b76e8eaf18c) | [853930](https://mempool.space/block/00000000000000000002eb5e9a7950ca2d5d98bd1ed28fc9098aa630d417985d) - 2024/07/26

-![Image of the Satonomics Web App version 0.3.0](https://github.com/kibo-money/kibo/blob/main/_assets/v0.3.0.jpg)
+![Image of the Satonomics Web App version 0.3.0](https://github.com/bitcoinresearchkit/brk/blob/main/assets/satonomics-v0.3.0.jpg)

 ## Parser

@@ -190,9 +192,9 @@ Full rewrite
  - Only run with a watcher if `cargo watch` is available
  - Removed id_to_path file in favor for only `paths.d.ts` in `app/src/types`

-# [kibo-v0.2.0](https://github.com/kibo-money/kibo/tree/248187889283597c5dbb806292297453c25e97b8) | [851286](https://mempool.space/block/0000000000000000000281ca7f1bf8c50702bfca168c7af1bdc67c977c1ac8ed) - 2024/07/08
+# [satonomics-v0.2.0](https://github.com/bitcoinresearchkit/brk/tree/248187889283597c5dbb806292297453c25e97b8) | [851286](https://mempool.space/block/0000000000000000000281ca7f1bf8c50702bfca168c7af1bdc67c977c1ac8ed) - 2024/07/08

-![Image of the Satonomics Web App version 0.2.0](https://github.com/kibo-money/kibo/blob/main/_assets/v0.2.0.jpg)
+![Image of the Satonomics Web App version 0.2.0](https://github.com/bitcoinresearchkit/brk/blob/main/assets/satonomics-v0.2.0.jpg)

 ## App

@@ -226,9 +228,9 @@ Full rewrite

 - Fixed ulimit only being run in Mac OS instead of whenever the program is detected

-# [kibo-v0.1.1](https://github.com/kibo-money/kibo/tree/e55b5195a9de9aea306903c94ed63cb1720fda5f) | [849240](https://mempool.space/block/000000000000000000002b8653988655071c07bb5f7181c038f9326bc86db741) - 2024/06/24
+# [satonomics-v0.1.1](https://github.com/bitcoinresearchkit/brk/tree/e55b5195a9de9aea306903c94ed63cb1720fda5f) | [849240](https://mempool.space/block/000000000000000000002b8653988655071c07bb5f7181c038f9326bc86db741) - 2024/06/24

-![Image of the Satonomics Web App version 0.1.1](https://github.com/kibo-money/kibo/blob/main/_assets/v0.1.1.jpg)
+![Image of the Satonomics Web App version 0.1.1](https://github.com/bitcoinresearchkit/brk/blob/main/assets/satonomics-v0.1.1.jpg)

 ## Parser

@@ -276,10 +278,10 @@ Full rewrite

 - Deleted old price datasets and their backups

-# [kibo-v0.1.0](https://github.com/kibo-money/kibo/tree/a1a576d088c8f83ed32d48753a7611f70a964574) | [848642](https://mempool.space/block/000000000000000000020be5761d70751252219a9557f55e91ecdfb86c4e026a) - 2024/06/19
+# [satonomics-v0.1.0](https://github.com/bitcoinresearchkit/brk/tree/a1a576d088c8f83ed32d48753a7611f70a964574) | [848642](https://mempool.space/block/000000000000000000020be5761d70751252219a9557f55e91ecdfb86c4e026a) - 2024/06/19

-![Image of the Satonomics Web App version 0.1.0](https://github.com/kibo-money/kibo/blob/main/_assets/v0.1.0.jpg)
+![Image of the Satonomics Web App version 0.1.0](https://github.com/bitcoinresearchkit/brk/blob/main/assets/satonomics-v0.1.0.jpg)

-# kibo-v0.0.1 | [835444](https://mempool.space/block/000000000000000000009f93907a0dd83c080d5585cc7ec82c076d45f6d7c872) - 2024/03/20
+# satonomics-v0.0.1 | [835444](https://mempool.space/block/000000000000000000009f93907a0dd83c080d5585cc7ec82c076d45f6d7c872) - 2024/03/20

-![Image of the Satonomics Web App version 0.0.X](https://github.com/kibo-money/kibo/blob/main/_assets/v0.0.X.jpg)
+![Image of the Satonomics Web App version 0.0.X](https://github.com/bitcoinresearchkit/brk/blob/main/assets/satonomics-v0.0.1.jpg)
@@ -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.46"
+package.version = "0.0.73"
 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,37 +26,41 @@ axum = "0.8.4"
 bincode = { version = "2.0.1", features = ["serde"] }
 bitcoin = { version = "0.32.6", features = ["serde"] }
 bitcoincore-rpc = "0.19.0"
-brk_cli = { version = "0", path = "crates/brk_cli" }
-brk_computer = { version = "0", path = "crates/brk_computer" }
-brk_core = { version = "0", path = "crates/brk_core" }
-brk_exit = { version = "0", path = "crates/brk_exit" }
-brk_fetcher = { version = "0", path = "crates/brk_fetcher" }
-brk_indexer = { version = "0", path = "crates/brk_indexer" }
-brk_logger = { version = "0", path = "crates/brk_logger" }
-brk_parser = { version = "0", path = "crates/brk_parser" }
-brk_query = { version = "0", path = "crates/brk_query" }
-brk_server = { version = "0", path = "crates/brk_server" }
-brk_state = { version = "0", path = "crates/brk_state" }
-brk_store = { version = "0", path = "crates/brk_store" }
-brk_vec = { version = "0", path = "crates/brk_vec" }
+brk_bundler = { version = "0.0.73", path = "crates/brk_bundler" }
+brk_cli = { version = "0.0.73", path = "crates/brk_cli" }
+brk_computer = { version = "0.0.73", path = "crates/brk_computer" }
+brk_core = { version = "0.0.73", path = "crates/brk_core" }
+brk_exit = { version = "0.0.73", path = "crates/brk_exit" }
+brk_fetcher = { version = "0.0.73", path = "crates/brk_fetcher" }
+brk_indexer = { version = "0.0.73", path = "crates/brk_indexer" }
+brk_interface = { version = "0.0.73", path = "crates/brk_interface" }
+brk_logger = { version = "0.0.73", path = "crates/brk_logger" }
+brk_mcp = { version = "0.0.73", path = "crates/brk_mcp" }
+brk_parser = { version = "0.0.73", 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.73", path = "crates/brk_server" }
+brk_store = { version = "0.0.73", path = "crates/brk_store" }
+brk_vec = { version = "0.0.73", path = "crates/brk_vec" }
 byteview = "=0.6.1"
-clap = { version = "4.5.39", features = ["string"] }
-clap_derive = "4.5.32"
+clap = { version = "4.5.40", features = ["string"] }
+clap_derive = "4.5.40"
 color-eyre = "0.6.5"
 derive_deref = "1.1.1"
-fjall = "2.11.0"
-jiff = "0.2.14"
+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.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"] }
-zerocopy = { version = "0.8.25" }
-zerocopy-derive = "0.8.25"
+tokio = { version = "1.46.1", features = ["rt-multi-thread"] }
+zerocopy = { version = "0.8.26" }
+zerocopy-derive = "0.8.26"

 [workspace.metadata.release]
 shared-version = true
@@ -31,20 +31,26 @@
  </a>
 </p>

-The Bitcoin Research Kit is a high-performance toolchain designed to parse, index, compute, serve and visualize data from a Bitcoin Core node, enabling users to gain deeper insights into the Bitcoin network.
+The Bitcoin Research Kit is a high-performance toolchain designed to parse, index, compute, serve and visualize data from a Bitcoin node, enabling users to gain deeper insights into the Bitcoin network.

-In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) (soon) and [electrs](https://github.com/romanz/electrs) (soon) all in one package with a particular focus on simplicity and the self-hosting experience.
+In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) (soon) and [electrs](https://github.com/romanz/electrs) (soon) all in one package with a particular focus on simplicity and ease of use.

 The toolkit can be used in various ways to accommodate as many needs as possible:

- **[Website](https://kibo.money)** \
-  Everyone is welcome to visit [kibo.money](https://kibo.money) which is the official showcase of the suite's capabilities and served by default when running BRK. \
-  Researchers and developers are free to use the API which endpoints documentation can be found [here](https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#endpoints). \
-  As a token of gratitude to the community and to stimulate curiosity, both the website and the API are entirely free, allowing anyone to use them.
+- **[Website](https://bitcoinresearchkit.org)** \
+  Everyone is welcome to visit the official instance and showcase of the suite's capabilities. \
+  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%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). \
+  It will give them access to the same tools as the API, with no restrictions, and allow you to have your very own data analysts. \
+  One-shot output examples: [Document](https://claude.ai/public/artifacts/71194d29-f965-417c-ba09-fdf0e4ecb1d5) // [Dashboard](https://claude.ai/public/artifacts/beef143f-399a-4ed4-b8bf-c986b776de42) // [Dashboard 2](https://claude.ai/public/artifacts/5430ae49-bb3d-4fc1-ab24-f1e33deb40dc)
 - **[CLI](https://crates.io/crates/brk_cli)** \
-  Node runners are strongly encouraged to try out and self-host their own instance. \
-  A lot of effort has gone into making this as easy as possible. \
-  For more information visit: [`brk_cli`](https://crates.io/crates/brk_cli)
+  Node runners are strongly encouraged to try out and self-host their own instance using BRK's command line interface. \
+  The CLI has multiple cogs available for users to tweak to adapt to all situations with even the possibility for web developers to create their own custom website which could later on be added as an alternative front-end.
 - **[Crates](https://crates.io/crates/brk)** \
  Rust developers have access to a wide range crates, each built upon one another with its own specific purpose, enabling independent use and offering great flexibility.
  PRs are welcome, especially if their goal is to introduce additional datasets.
@@ -56,35 +62,28 @@ In contrast, existing alternatives tend to be either [very costly](https://studi
 ## Crates

 - [`brk`](https://crates.io/crates/brk): Wrapper around all other `brk-*` crates
- [`brk_cli`](https://crates.io/crates/brk_cli): A standalone command line interface to interact with the Bitcoin Research Kit
+- [`brk_cli`](https://crates.io/crates/brk_cli): A command line interface to run a Bitcoin Research Kit instance
 - [`brk_computer`](https://crates.io/crates/brk_computer): A Bitcoin dataset computer, built on top of brk_indexer
 - [`brk_core`](https://crates.io/crates/brk_core): The Core (Structs and Errors) of the Bitcoin Research Kit
 - [`brk_exit`](https://crates.io/crates/brk_exit): An exit blocker built on top of ctrlc
 - [`brk_fetcher`](https://crates.io/crates/brk_fetcher): A Bitcoin price fetcher
 - [`brk_indexer`](https://crates.io/crates/brk_indexer): A Bitcoin Core indexer built on top of brk_parser
- [`brk_logger`](https://crates.io/crates/brk_logger): A clean logger used in the Bitcoin Research Kit.
+- [`brk_logger`](https://crates.io/crates/brk_logger): A clean logger used in the Bitcoin Research Kit
+- [`brk_mcp`](https://crates.io/crates/brk_mcp): A Model Context Protocol (MCP) which gives LLMs access to all available tools in BRK
 - [`brk_parser`](https://crates.io/crates/brk_parser): A very fast Bitcoin Core block parser and iterator built on top of bitcoin-rust
- [`brk_query`](https://crates.io/crates/brk_query): A library that finds requested datasets.
+- [`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
-
-## Acknowledgments
-
-Deepest gratitude to the [Open Sats](https://opensats.org/) public charity. Their grant — from December 2024 to the present — has been critical in sustaining this project.
-
-Heartfelt thanks go out to every donor on [Nostr](https://primal.net/p/npub1jagmm3x39lmwfnrtvxcs9ac7g300y3dusv9lgzhk2e4x5frpxlrqa73v44) and [Geyser.fund](https://geyser.fund/project/brk) whose support has ensured the availability of the [kibo.money](https://kibo.money) public instance.
+- [`brk_bundler`](https://crates.io/crates/brk_bundler): A thin wrapper around [`rolldown`](https://rolldown.rs/)

 ## Hosting as a service

-*Soon™*
-
 If you'd like to have your own instance hosted for you please contact [hosting@bitcoinresearchkit.org](mailto:hosting@bitcoinresearchkit.org).

 - 2 separate dedicated servers (1 GB/s each) with different ISPs and Cloudflare integration for enhanced performance and optimal availability
 - 99.99% SLA
- Configurated for speed (`raw + eager`)
+- Configured for speed
 - Updates delivered at your convenience
 - Direct communication for feature requests and support
 - Bitcoin Core or Knots with desired version
@@ -93,6 +92,12 @@ If you'd like to have your own instance hosted for you please contact [hosting@b

 Pricing: `0.01 BTC / month` *or* `0.1 BTC / year`

+## Acknowledgments
+
+Deepest gratitude to the [Open Sats](https://opensats.org/) public charity. Their grant — from December 2024 to the present — has been critical in sustaining this project.
+
+Heartfelt thanks go out to every donor on [Nostr](https://primal.net/p/npub1jagmm3x39lmwfnrtvxcs9ac7g300y3dusv9lgzhk2e4x5frpxlrqa73v44) and [Geyser.fund](https://geyser.fund/project/brk) whose support has ensured the availability of the [bitcoinresearchkit.org](https://bitcoinresearchkit.org) public instance.
+
 ## Donate

 [`bc1q09 8zsm89 m7kgyz e338vf ejhpdt 92ua9p 3peuve`](bitcoin:bc1q098zsm89m7kgyze338vfejhpdt92ua9p3peuve)
@@ -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
@@ -0,0 +1,2 @@
+profile.json.gz
+flamegraph.svg
@@ -10,33 +10,36 @@ version.workspace = true

 [features]
 full = [
+    "bundler",
    "core",
    "computer",
    "exit",
    "fetcher",
    "indexer",
    "logger",
+    "mcp",
    "parser",
-    "query",
+    "interface",
    "server",
-    "state",
    "store",
    "vec",
 ]
+bundler = ["brk_bundler"]
 core = ["brk_core"]
 computer = ["brk_computer"]
 exit = ["brk_exit"]
 fetcher = ["brk_fetcher"]
 indexer = ["brk_indexer"]
 logger = ["brk_logger"]
+mcp = ["brk_mcp"]
 parser = ["brk_parser"]
-query = ["brk_query"]
+interface = ["brk_interface"]
 server = ["brk_server"]
-state = ["brk_state"]
 store = ["brk_store"]
 vec = ["brk_vec"]

 [dependencies]
+brk_bundler = { workspace = true, optional = true }
 brk_cli = { workspace = true }
 brk_core = { workspace = true, optional = true }
 brk_computer = { workspace = true, optional = true }
@@ -44,10 +47,10 @@ brk_exit = { workspace = true, optional = true }
 brk_fetcher = { workspace = true, optional = true }
 brk_indexer = { workspace = true, optional = true }
 brk_logger = { workspace = true, optional = true }
+brk_mcp = { workspace = true, optional = true }
 brk_parser = { workspace = true, optional = true }
-brk_query = { 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 }

@@ -0,0 +1 @@
+fn main() {}
@@ -0,0 +1,2 @@
+cargo build --profile profiling
+flamegraph -- ../../target/profiling/brk
@@ -0,0 +1,2 @@
+cargo build --profile profiling
+samply record ../../target/profiling/brk
@@ -1,5 +1,12 @@
 #![doc = include_str!(concat!("../", env!("CARGO_PKG_README")))]

+#[cfg(feature = "bundler")]
+#[doc(inline)]
+pub use brk_bundler as bundler;
+
+#[doc(inline)]
+pub use brk_cli as cli;
+
 #[cfg(feature = "core")]
 #[doc(inline)]
 pub use brk_core as core;
@@ -24,22 +31,22 @@ pub use brk_indexer as indexer;
 #[doc(inline)]
 pub use brk_logger as logger;

+#[cfg(feature = "mcp")]
+#[doc(inline)]
+pub use brk_mcp as mcp;
+
 #[cfg(feature = "parser")]
 #[doc(inline)]
 pub use brk_parser as parser;

-#[cfg(feature = "query")]
+#[cfg(feature = "interface")]
 #[doc(inline)]
-pub use brk_query as query;
+pub use brk_interface as interface;

 #[cfg(feature = "server")]
 #[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;
@@ -0,0 +1,16 @@
+[package]
+name = "brk_bundler"
+description = "A thin wrapper around rolldown"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[dependencies]
+log = { workspace = true }
+notify = "8.1.0"
+brk_rolldown = "0.1.0"
+# brk_rolldown = { path = "../../../rolldown/crates/rolldown"}
+sugar_path = "1.2.0"
+tokio = { workspace = true }
@@ -0,0 +1,145 @@
+use std::{fs, io, path::Path, sync::Arc};
+
+use brk_rolldown::{Bundler, BundlerOptions, RawMinifyOptions, SourceMapType};
+use log::error;
+use notify::{EventKind, RecursiveMode, Watcher};
+use sugar_path::SugarPath;
+use tokio::sync::Mutex;
+
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> io::Result<()> {
+    let source_path = websites_path.join(source_folder);
+    let dist_path = websites_path.join("dist");
+
+    let _ = fs::remove_dir_all(&dist_path);
+    copy_dir_all(&source_path, &dist_path)?;
+
+    let source_scripts = format!("./{source_folder}/scripts");
+    let source_entry = format!("{source_scripts}/entry.js");
+
+    let absolute_websites_path = websites_path.absolutize();
+
+    let mut bundler = Bundler::new(BundlerOptions {
+        input: Some(vec![source_entry.into()]),
+        dir: Some("./dist/scripts".to_string()),
+        cwd: Some(absolute_websites_path),
+        minify: Some(RawMinifyOptions::Bool(true)),
+        sourcemap: Some(SourceMapType::File),
+        ..Default::default()
+    });
+
+    bundler.write().await.unwrap();
+
+    let absolute_source_index_path = source_path.join("index.html").absolutize();
+    let absolute_source_index_path_clone = absolute_source_index_path.clone();
+    let absolute_source_path = source_path.absolutize();
+    let absolute_source_path_clone = absolute_source_path.clone();
+    let absolute_source_scripts_path = websites_path.join(source_scripts).absolutize();
+    let absolute_source_sw_path = source_path.join("service-worker.js").absolutize();
+    let absolute_source_sw_path_clone = absolute_source_sw_path.clone();
+
+    let absolute_dist_entry_path = dist_path.join("scripts/entry.js").absolutize();
+    let absolute_dist_index_path = dist_path.join("index.html").absolutize();
+    let absolute_dist_path = dist_path.absolutize();
+    let absolute_dist_path_clone = absolute_dist_path.clone();
+    let absolute_dist_sw_path = dist_path.join("service-worker.js").absolutize();
+
+    let write_index = move || {
+        let mut contents = fs::read_to_string(&absolute_source_index_path).unwrap();
+
+        if let Ok(entry) = fs::read_to_string(absolute_dist_path_clone.join("scripts/entry.js")) {
+            if let Some(start) = entry.find("main") {
+                if let Some(end) = entry.find(".js") {
+                    let main_hashed = &entry[start..end];
+                    contents =
+                        contents.replace("/scripts/main.js", &format!("/scripts/{main_hashed}.js"));
+                }
+            }
+        }
+
+        let _ = fs::write(&absolute_dist_index_path, contents);
+    };
+
+    let write_sw = move || {
+        let contents = fs::read_to_string(&absolute_source_sw_path)
+            .unwrap()
+            .replace("__VERSION__", &format!("v{VERSION}"));
+        let _ = fs::write(&absolute_dist_sw_path, contents);
+    };
+
+    write_index();
+    write_sw();
+
+    if !watch {
+        return Ok(());
+    }
+
+    tokio::spawn(async move {
+        let write_index_clone = write_index.clone();
+
+        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:?}"),
+            },
+        )
+        .unwrap();
+
+        entry_watcher
+            .watch(&absolute_dist_entry_path, RecursiveMode::Recursive)
+            .unwrap();
+
+        let mut source_watcher = notify::recommended_watcher(
+            move |res: Result<notify::Event, notify::Error>| match res {
+                Ok(event) => match event.kind {
+                    EventKind::Create(_) => event.paths,
+                    EventKind::Modify(_) => event.paths,
+                    _ => vec![],
+                }
+                .into_iter()
+                .filter(|path| path.starts_with(&absolute_source_path))
+                .filter(|path| !path.starts_with(&absolute_source_scripts_path))
+                .for_each(|source_path| {
+                    let suffix = source_path.strip_prefix(&absolute_source_path).unwrap();
+                    let dist_path = absolute_dist_path.join(suffix);
+
+                    if source_path == absolute_source_index_path_clone {
+                        write_index();
+                    } else if source_path == absolute_source_sw_path_clone {
+                        write_sw();
+                    } else {
+                        let _ = fs::copy(&source_path, &dist_path);
+                    }
+                }),
+                Err(e) => error!("watch error: {e:?}"),
+            },
+        )
+        .unwrap();
+
+        source_watcher
+            .watch(&absolute_source_path_clone, RecursiveMode::Recursive)
+            .unwrap();
+
+        let watcher =
+            brk_rolldown::Watcher::new(vec![Arc::new(Mutex::new(bundler))], None).unwrap();
+
+        watcher.start().await;
+    });
+
+    Ok(())
+}
+
+fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
+    fs::create_dir_all(&dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        if ty.is_dir() {
+            copy_dir_all(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        } else {
+            fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        }
+    }
+    Ok(())
+}
@@ -1,6 +1,6 @@
 [package]
 name = "brk_cli"
-description = "A command line interface to interact with the full Bitcoin Research Kit"
+description = "A command line interface to run a Bitcoin Research Kit instance"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
@@ -16,7 +16,6 @@ brk_fetcher = { workspace = true }
 brk_indexer = { workspace = true }
 brk_logger = { workspace = true }
 brk_parser = { workspace = true }
-brk_query = { workspace = true }
 brk_server = { workspace = true }
 brk_vec = { workspace = true }
 clap = { workspace = true }
@@ -24,9 +23,8 @@ clap_derive = { workspace = true }
 color-eyre = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true }
-tabled = { workspace = true }
 tokio = { workspace = true }
-toml = "0.8.23"
+toml = "0.9.0"

 [[bin]]
 name = "brk"
@@ -1,4 +1,4 @@
-# BRK Cli
+# BRK CLI

 <p align="left">
  <a href="https://github.com/bitcoinresearchkit/brk">
@@ -31,9 +31,11 @@
  </a>
 </p>

-A command line interface to interact with the full Bitcoin Research Kit. It's built on top of every other create and gives the possility to use BRK using the terminal instead of Rust.
+A command line interface to run a Bitcoin Research Kit instance.

-It has 2 commandes for now (other than `help` and `version`) which are `run` and `query`. The former is used to run the processing (indexer + computer) and/or the server. The latter uses `brk_query` as its backend just like to server to be able to get datasets via the terminal instead of the API. Both commands are very costumizable by having all the parameters of their Rust counterparts ([`run`](https://github.com/bitcoinresearchkit/brk/blob/main/crates/brk_cli/src/run.rs#L91-L147), [`query`](https://github.com/bitcoinresearchkit/brk/blob/main/crates/brk_query/src/params.rs)).
+It's very customizable with all parameters from the underlying tools (crates) used inside.
+
+Run `brk -h` for more information.

 ## Requirements

@@ -54,13 +56,15 @@ To be determined
 - [Bitcoin](https://bitcoin.org/en/full-node)
 - [Rust](https://www.rust-lang.org/tools/install)
 - Unix based operating system (Mac OS or Linux)
-  - Ubuntu users need to install `open-ssl` via `sudo apt install libssl-dev pkg-config`
+
+> [!IMPORTANT]
+> Ubuntu users need to install `open-ssl` via `sudo apt install libssl-dev pkg-config`

 ## Download

 ### Binaries

-You can find a pre-built binary for your operating system on the releases page ([link](https://github.com/bitcoinresearchkit/brk/releases/latest)).
+You can find a pre-built binary for your operating system in the [releases page](https://github.com/bitcoinresearchkit/brk/releases/latest).

 ### Cargo

@@ -82,10 +86,11 @@ cargo run -r

 ## Usage

-Run `brk -h` to view each available command and their respective description.
+Run `brk -h` to view each available parameter and their respective description.

-`-h` works also for commands, which mean that `brk run -h` will explain all the parameters of `brk run` for example.
+> [!TIP]
+> Every parameter set will be saved at `~/.brk/config.toml`, which allows you to simply run `brk` next time.

-Every parameter set for `brk run` will be saved at `~/.brk/config.toml`, which will allow you to simply run `brk run` next time.
+## Tunnel

-Then the easiest to let others access your server is to use `cloudflared` which will also cache requests. For more information go to: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/
+The easiest way to let others access your server is to use `cloudflared` which will also cache requests. For more information see [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) documentation.
@@ -0,0 +1,376 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use bitcoincore_rpc::{self, Auth, Client};
+use brk_core::{default_bitcoin_path, default_brk_path, default_on_error, dot_brk_path};
+use brk_fetcher::Fetcher;
+use brk_server::Website;
+use brk_vec::{Computation, Format};
+use clap::Parser;
+use clap_derive::Parser;
+use color_eyre::eyre::eyre;
+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")]
+    #[arg(long, value_name = "PATH")]
+    bitcoindir: Option<String>,
+
+    /// Bitcoin blocks directory path, default: --bitcoindir/blocks, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "PATH")]
+    blocksdir: Option<String>,
+
+    /// Bitcoin Research Kit outputs directory path, default: ~/.brk, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "PATH")]
+    brkdir: Option<String>,
+
+    /// Activated services, default: all, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(short, long)]
+    services: Option<Services>,
+
+    /// Computation of computed datasets, `lazy` computes data whenever requested without saving it, `eager` computes the data once and saves it to disk, default: `lazy`, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(short, long)]
+    computation: Option<Computation>,
+
+    /// Format of computed datasets, `compressed` to save disk space (experimental), `raw` to prioritize speed, default: `raw`, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(short, long)]
+    format: Option<Format>,
+
+    /// Activate fetching prices from exchanges APIs and the computation of all related datasets, default: true, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(short = 'F', long, value_name = "BOOL")]
+    fetch: Option<bool>,
+
+    /// Website served by the server (if active), default: default, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(short, long)]
+    website: Option<Website>,
+
+    /// Bitcoin RPC ip, default: localhost, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "IP")]
+    rpcconnect: Option<String>,
+
+    /// Bitcoin RPC port, default: 8332, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "PORT")]
+    rpcport: Option<u16>,
+
+    /// Bitcoin RPC cookie file, default: --bitcoindir/.cookie, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "PATH")]
+    rpccookiefile: Option<String>,
+
+    /// Bitcoin RPC username, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "USERNAME")]
+    rpcuser: Option<String>,
+
+    /// Bitcoin RPC password, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "PASSWORD")]
+    rpcpassword: Option<String>,
+
+    /// Delay between runs, default: 0, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "SECONDS")]
+    delay: Option<u64>,
+
+    /// 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>,
+
+    /// DEV: Activate watching the selected website's folder for changes, default: false, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "BOOL")]
+    watch: Option<bool>,
+
+    /// DEV: Activate checking address hashes for collisions when indexing, default: false, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "BOOL")]
+    check_collisions: Option<bool>,
+}
+
+impl Config {
+    pub fn import() -> color_eyre::Result<Self> {
+        let config_args = Some(Config::parse());
+
+        let path = dot_brk_path();
+
+        let _ = fs::create_dir_all(&path);
+
+        let path = path.join("config.toml");
+
+        let mut config_saved = Self::read(&path);
+
+        if let Some(mut config_args) = config_args {
+            if let Some(bitcoindir) = config_args.bitcoindir.take() {
+                config_saved.bitcoindir = Some(bitcoindir);
+            }
+
+            if let Some(blocksdir) = config_args.blocksdir.take() {
+                config_saved.blocksdir = Some(blocksdir);
+            }
+
+            if let Some(brkdir) = config_args.brkdir.take() {
+                config_saved.brkdir = Some(brkdir);
+            }
+
+            if let Some(services) = config_args.services.take() {
+                config_saved.services = Some(services);
+            }
+
+            if let Some(computation) = config_args.computation.take() {
+                config_saved.computation = Some(computation);
+            }
+
+            if let Some(fetch) = config_args.fetch.take() {
+                config_saved.fetch = Some(fetch);
+            }
+
+            if let Some(format) = config_args.format.take() {
+                config_saved.format = Some(format);
+            }
+
+            if let Some(website) = config_args.website.take() {
+                config_saved.website = Some(website);
+            }
+
+            if let Some(rpcconnect) = config_args.rpcconnect.take() {
+                config_saved.rpcconnect = Some(rpcconnect);
+            }
+
+            if let Some(rpcport) = config_args.rpcport.take() {
+                config_saved.rpcport = Some(rpcport);
+            }
+
+            if let Some(rpccookiefile) = config_args.rpccookiefile.take() {
+                config_saved.rpccookiefile = Some(rpccookiefile);
+            }
+
+            if let Some(rpcuser) = config_args.rpcuser.take() {
+                config_saved.rpcuser = Some(rpcuser);
+            }
+
+            if let Some(rpcpassword) = config_args.rpcpassword.take() {
+                config_saved.rpcpassword = Some(rpcpassword);
+            }
+
+            if let Some(delay) = config_args.delay.take() {
+                config_saved.delay = Some(delay);
+            }
+
+            if let Some(check_collisions) = config_args.check_collisions.take() {
+                config_saved.check_collisions = Some(check_collisions);
+            }
+
+            if let Some(mcp) = config_args.mcp.take() {
+                config_saved.mcp = Some(mcp);
+            }
+
+            if let Some(watch) = config_args.watch.take() {
+                config_saved.watch = Some(watch);
+            }
+
+            if config_args != Config::default() {
+                dbg!(config_args);
+                panic!("Didn't consume the full config")
+            }
+        }
+
+        let config = config_saved;
+
+        config.check();
+
+        config.write(&path)?;
+
+        Ok(config)
+    }
+
+    fn check(&self) {
+        if !self.bitcoindir().is_dir() {
+            println!("{:?} isn't a valid directory", self.bitcoindir());
+            println!("Please use the --bitcoindir parameter to set a valid path.");
+            println!("Run the program with '-h' for help.");
+            std::process::exit(1);
+        }
+
+        if !self.blocksdir().is_dir() {
+            println!("{:?} isn't a valid directory", self.blocksdir());
+            println!("Please use the --blocksdir parameter to set a valid path.");
+            println!("Run the program with '-h' for help.");
+            std::process::exit(1);
+        }
+
+        if !self.brkdir().is_dir() {
+            println!("{:?} isn't a valid directory", self.brkdir());
+            println!("Please use the --brkdir parameter to set a valid path.");
+            println!("Run the program with '-h' for help.");
+            std::process::exit(1);
+        }
+
+        if self.rpc_auth().is_err() {
+            println!(
+                "No way found to authenticate the RPC client, please either set --rpccookiefile or --rpcuser and --rpcpassword.\nRun the program with '-h' for help."
+            );
+            std::process::exit(1);
+        }
+    }
+
+    fn read(path: &Path) -> Self {
+        fs::read_to_string(path).map_or_else(
+            |_| Config::default(),
+            |contents| toml::from_str(&contents).unwrap_or_default(),
+        )
+    }
+
+    fn write(&self, path: &Path) -> std::io::Result<()> {
+        fs::write(path, toml::to_string(self).unwrap())
+    }
+
+    pub fn rpc(&self) -> color_eyre::Result<&'static Client> {
+        Ok(Box::leak(Box::new(Client::new(
+            &format!(
+                "http://{}:{}",
+                self.rpcconnect().unwrap_or(&"localhost".to_string()),
+                self.rpcport().unwrap_or(8332)
+            ),
+            self.rpc_auth().unwrap(),
+        )?)))
+    }
+
+    fn rpc_auth(&self) -> color_eyre::Result<Auth> {
+        let cookie = self.path_cookiefile();
+
+        if cookie.is_file() {
+            Ok(Auth::CookieFile(cookie))
+        } else if self.rpcuser.is_some() && self.rpcpassword.is_some() {
+            Ok(Auth::UserPass(
+                self.rpcuser.clone().unwrap(),
+                self.rpcpassword.clone().unwrap(),
+            ))
+        } else {
+            Err(eyre!("Failed to find correct auth"))
+        }
+    }
+
+    fn rpcconnect(&self) -> Option<&String> {
+        self.rpcconnect.as_ref()
+    }
+
+    fn rpcport(&self) -> Option<u16> {
+        self.rpcport
+    }
+
+    pub fn delay(&self) -> Option<u64> {
+        self.delay
+    }
+
+    pub fn bitcoindir(&self) -> PathBuf {
+        self.bitcoindir
+            .as_ref()
+            .map_or_else(default_bitcoin_path, |s| Self::fix_user_path(s.as_ref()))
+    }
+
+    pub fn blocksdir(&self) -> PathBuf {
+        self.blocksdir.as_ref().map_or_else(
+            || self.bitcoindir().join("blocks"),
+            |blocksdir| Self::fix_user_path(blocksdir.as_str()),
+        )
+    }
+
+    pub fn brkdir(&self) -> PathBuf {
+        self.brkdir
+            .as_ref()
+            .map_or_else(default_brk_path, |s| Self::fix_user_path(s.as_ref()))
+    }
+
+    pub fn outputsdir(&self) -> PathBuf {
+        self.brkdir().join("outputs")
+    }
+
+    pub fn harsdir(&self) -> PathBuf {
+        self.outputsdir().join("hars")
+    }
+
+    pub fn process(&self) -> bool {
+        self.services
+            .is_none_or(|m| m == Services::All || m == Services::Processor)
+    }
+
+    pub fn serve(&self) -> bool {
+        self.services
+            .is_none_or(|m| m == Services::All || m == Services::Server)
+    }
+
+    fn path_cookiefile(&self) -> PathBuf {
+        self.rpccookiefile.as_ref().map_or_else(
+            || self.bitcoindir().join(".cookie"),
+            |p| Self::fix_user_path(p.as_str()),
+        )
+    }
+
+    fn fix_user_path(path: &str) -> PathBuf {
+        let fix = move |pattern: &str| {
+            if path.starts_with(pattern) {
+                let path = &path
+                    .replace(&format!("{pattern}/"), "")
+                    .replace(pattern, "");
+
+                let home = std::env::var("HOME").unwrap();
+
+                Some(Path::new(&home).join(path))
+            } else {
+                None
+            }
+        };
+
+        fix("~").unwrap_or_else(|| fix("$HOME").unwrap_or_else(|| PathBuf::from(&path)))
+    }
+
+    pub fn website(&self) -> Website {
+        self.website.unwrap_or(Website::Default)
+    }
+
+    pub fn fetch(&self) -> bool {
+        self.fetch.is_none_or(|b| b)
+    }
+
+    pub fn fetcher(&self) -> Option<Fetcher> {
+        self.fetch()
+            .then(|| Fetcher::import(Some(self.harsdir().as_path())).unwrap())
+    }
+
+    pub fn computation(&self) -> Computation {
+        self.computation.unwrap_or_default()
+    }
+
+    pub fn format(&self) -> Format {
+        self.format.unwrap_or_default()
+    }
+
+    pub fn check_collisions(&self) -> bool {
+        self.check_collisions.is_some_and(|b| b)
+    }
+
+    pub fn mcp(&self) -> bool {
+        self.mcp.is_none_or(|b| b)
+    }
+
+    pub fn watch(&self) -> bool {
+        self.watch.is_some_and(|b| b)
+    }
+}
@@ -1,30 +1,12 @@
-use std::fs;
+use std::{fs, thread};

 use brk_core::{dot_brk_log_path, dot_brk_path};
-use brk_query::Params as QueryArgs;
-use clap::Parser;
-use clap_derive::{Parser, Subcommand};
-use query::query;
-use run::{RunConfig, run};

-mod query;
+mod config;
 mod run;
+mod services;

-#[derive(Parser)]
-#[command(version, about)]
-#[command(propagate_version = true)]
-struct Cli {
-    #[command(subcommand)]
-    command: Commands,
-}
-
-#[derive(Subcommand, Debug)]
-enum Commands {
-    /// Run the indexer, computer and server
-    Run(RunConfig),
-    /// Query generated datasets via the `run` command in a similar fashion as the server's API
-    Query(QueryArgs),
-}
+use run::*;

 pub fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;
@@ -33,10 +15,9 @@ pub fn main() -> color_eyre::Result<()> {

    brk_logger::init(Some(&dot_brk_log_path()));

-    let cli = Cli::parse();
-
-    match cli.command {
-        Commands::Run(args) => run(args),
-        Commands::Query(args) => query(args),
-    }
+    thread::Builder::new()
+        .stack_size(256 * 1024 * 1024)
+        .spawn(run)?
+        .join()
+        .unwrap()
 }
@@ -1,53 +0,0 @@
-use brk_computer::Computer;
-use brk_indexer::Indexer;
-use brk_query::{Index, Output, Params as QueryParams, Query, Tabled, Value};
-use tabled::settings::Style;
-
-use crate::run::RunConfig;
-
-pub fn query(params: QueryParams) -> color_eyre::Result<()> {
-    let config = RunConfig::import(None)?;
-
-    let format = config.format();
-
-    let mut indexer = Indexer::new(&config.outputsdir(), format, config.check_collisions())?;
-    indexer.import_vecs()?;
-
-    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), format);
-    computer.import_vecs(&indexer, config.computation())?;
-
-    let query = Query::build(&indexer, &computer);
-
-    let index = Index::try_from(params.index.as_str())?;
-
-    let ids = params.values.iter().map(|s| s.as_str()).collect::<Vec<_>>();
-
-    let res = query.search_and_format(index, &ids, params.from, params.to, params.format)?;
-
-    if params.format.is_some() {
-        println!("{}", res);
-    } else {
-        println!(
-            "{}",
-            match res {
-                Output::Json(v) => match v {
-                    Value::Single(v) => v.to_string().replace("\"", ""),
-                    v => {
-                        let v = match v {
-                            Value::Single(_) => unreachable!("Already processed"),
-                            Value::List(v) => vec![v],
-                            Value::Matrix(v) => v,
-                        };
-                        let mut table =
-                            v.to_table(ids.iter().map(|id| id.to_string()).collect::<Vec<_>>());
-                        table.with(Style::psql());
-                        table.to_string()
-                    }
-                },
-                _ => unreachable!(),
-            }
-        );
-    }
-
-    Ok(())
-}
@@ -1,25 +1,16 @@
-use std::{
-    fs,
-    path::{Path, PathBuf},
-    thread::{self, sleep},
-    time::Duration,
-};
+use std::{thread::sleep, time::Duration};

-use bitcoincore_rpc::{self, Auth, Client, RpcApi};
+use bitcoincore_rpc::{self, RpcApi};
 use brk_computer::Computer;
-use brk_core::{default_bitcoin_path, default_brk_path, dot_brk_path};
 use brk_exit::Exit;
-use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
-use brk_server::{Server, Website};
-use brk_vec::{Computation, Format};
-use clap_derive::{Parser, ValueEnum};
-use color_eyre::eyre::eyre;
+use brk_server::Server;
 use log::info;
-use serde::{Deserialize, Serialize};

-pub fn run(config: RunConfig) -> color_eyre::Result<()> {
-    let config = RunConfig::import(Some(config))?;
+use crate::config::Config;
+
+pub fn run() -> color_eyre::Result<()> {
+    let config = Config::import()?;

    let rpc = config.rpc()?;

@@ -29,9 +20,7 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {

    let format = config.format();

-    let mut indexer = Indexer::new(&config.outputsdir(), format, config.check_collisions())?;
-    indexer.import_stores()?;
-    indexer.import_vecs()?;
+    let mut indexer = Indexer::forced_import(&config.outputsdir())?;

    let wait_for_synced_node = || -> color_eyre::Result<()> {
        let is_synced = || -> color_eyre::Result<bool> {
@@ -49,417 +38,66 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
        Ok(())
    };

-    let f = move || -> color_eyre::Result<()> {
-        let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), format);
-        computer.import_stores(&indexer)?;
-        computer.import_vecs(&indexer, config.computation())?;
-
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()?
-            .block_on(async {
-                let server = if config.serve() {
-                    let served_indexer = indexer.clone();
-                    let served_computer = computer.clone();
-
-                    let server = Server::new(served_indexer, served_computer, config.website())?;
-
-                    let opt = Some(tokio::spawn(async move {
-                        server.serve().await.unwrap();
-                    }));
-
-                    sleep(Duration::from_secs(1));
-
-                    opt
-                } else {
-                    None
-                };
-
-                if config.process() {
-                    loop {
-                        wait_for_synced_node()?;
-
-                        let block_count = rpc.get_block_count()?;
-
-                        info!("{} blocks found.", block_count + 1);
-
-                        let starting_indexes = indexer.index(&parser, rpc, &exit)?;
-
-                        computer.compute(&mut indexer, starting_indexes, &exit)?;
-
-                        if let Some(delay) = config.delay() {
-                            sleep(Duration::from_secs(delay))
-                        }
-
-                        info!("Waiting for new blocks...");
-
-                        while block_count == rpc.get_block_count()? {
-                            sleep(Duration::from_secs(1))
-                        }
-                    }
-                }
-
-                if let Some(handle) = server {
-                    handle.await.unwrap();
-                }
-
-                Ok(())
-            })
-    };
-
-    thread::Builder::new()
-        .stack_size(128 * 1024 * 1024)
-        .spawn(f)?
-        .join()
-        .unwrap()
-}
-
-#[derive(Parser, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
-pub struct RunConfig {
-    /// Bitcoin main directory path, defaults: ~/.bitcoin, ~/Library/Application\ Support/Bitcoin, saved
-    #[arg(long, value_name = "PATH")]
-    bitcoindir: Option<String>,
-
-    /// Bitcoin blocks directory path, default: --bitcoindir/blocks, saved
-    #[arg(long, value_name = "PATH")]
-    blocksdir: Option<String>,
-
-    /// Bitcoin Research Kit outputs directory path, default: ~/.brk, saved
-    #[arg(long, value_name = "PATH")]
-    brkdir: Option<String>,
-
-    /// Executed by the runner, default: all, saved
-    #[arg(short, long)]
-    mode: Option<Mode>,
-
-    /// Computation mode for compatible datasets, `lazy` computes data whenever requested without saving it, `eager` computes the data once and saves it to disk, default: Lazy, saved
-    #[arg(short, long)]
-    computation: Option<Computation>,
-
-    /// Activate compression of datasets, set to true to save disk space or false if prioritize speed, default: true, saved
-    #[arg(short, long, value_name = "FORMAT")]
-    format: Option<Format>,
-
-    /// Activate fetching prices from exchanges APIs and the computation of all related datasets, default: true, saved
-    #[arg(short = 'F', long, value_name = "BOOL")]
-    fetch: Option<bool>,
-
-    /// Website served by the server (if active), default: default, saved
-    #[arg(short, long)]
-    website: Option<Website>,
-
-    /// Bitcoin RPC ip, default: localhost, saved
-    #[arg(long, value_name = "IP")]
-    rpcconnect: Option<String>,
-
-    /// Bitcoin RPC port, default: 8332, saved
-    #[arg(long, value_name = "PORT")]
-    rpcport: Option<u16>,
-
-    /// Bitcoin RPC cookie file, default: --bitcoindir/.cookie, saved
-    #[arg(long, value_name = "PATH")]
-    rpccookiefile: Option<String>,
-
-    /// Bitcoin RPC username, saved
-    #[arg(long, value_name = "USERNAME")]
-    rpcuser: Option<String>,
-
-    /// Bitcoin RPC password, saved
-    #[arg(long, value_name = "PASSWORD")]
-    rpcpassword: Option<String>,
-
-    /// Delay between runs, default: 0, saved
-    #[arg(long, value_name = "SECONDS")]
-    delay: Option<u64>,
-
-    /// DEV: Activate checking address hashes for collisions when indexing, default: false, saved
-    #[arg(long, value_name = "BOOL")]
-    check_collisions: Option<bool>,
-}
-
-impl RunConfig {
-    pub fn import(config_args: Option<RunConfig>) -> color_eyre::Result<Self> {
-        let path = dot_brk_path();
-
-        let _ = fs::create_dir_all(&path);
-
-        let path = path.join("config.toml");
-
-        let mut config_saved = Self::read(&path);
-
-        if let Some(mut config_args) = config_args {
-            if let Some(bitcoindir) = config_args.bitcoindir.take() {
-                config_saved.bitcoindir = Some(bitcoindir);
-            }
-
-            if let Some(blocksdir) = config_args.blocksdir.take() {
-                config_saved.blocksdir = Some(blocksdir);
-            }
-
-            if let Some(brkdir) = config_args.brkdir.take() {
-                config_saved.brkdir = Some(brkdir);
-            }
-
-            if let Some(mode) = config_args.mode.take() {
-                config_saved.mode = Some(mode);
-            }
-
-            if let Some(computation) = config_args.computation.take() {
-                config_saved.computation = Some(computation);
-            }
-
-            if let Some(fetch) = config_args.fetch.take() {
-                config_saved.fetch = Some(fetch);
-            }
-
-            if let Some(format) = config_args.format.take() {
-                config_saved.format = Some(format);
-            }
-
-            if let Some(website) = config_args.website.take() {
-                config_saved.website = Some(website);
-            }
-
-            if let Some(rpcconnect) = config_args.rpcconnect.take() {
-                config_saved.rpcconnect = Some(rpcconnect);
-            }
-
-            if let Some(rpcport) = config_args.rpcport.take() {
-                config_saved.rpcport = Some(rpcport);
-            }
-
-            if let Some(rpccookiefile) = config_args.rpccookiefile.take() {
-                config_saved.rpccookiefile = Some(rpccookiefile);
-            }
-
-            if let Some(rpcuser) = config_args.rpcuser.take() {
-                config_saved.rpcuser = Some(rpcuser);
-            }
-
-            if let Some(rpcpassword) = config_args.rpcpassword.take() {
-                config_saved.rpcpassword = Some(rpcpassword);
-            }
-
-            if let Some(delay) = config_args.delay.take() {
-                config_saved.delay = Some(delay);
-            }
-
-            if let Some(check_collisions) = config_args.check_collisions.take() {
-                config_saved.check_collisions = Some(check_collisions);
-            }
-
-            if config_args != RunConfig::default() {
-                dbg!(config_args);
-                panic!("Didn't consume the full config")
-            }
-        }
-
-        let config = config_saved;
-
-        config.check();
-
-        config.write(&path)?;
-
-        // info!("Configuration {{");
-        // info!("  bitcoindir: {:?}", config.bitcoindir);
-        // info!("  brkdir: {:?}", config.brkdir);
-        // info!("  mode: {:?}", config.mode);
-        // info!("  website: {:?}", config.website);
-        // info!("  rpcconnect: {:?}", config.rpcconnect);
-        // info!("  rpcport: {:?}", config.rpcport);
-        // info!("  rpccookiefile: {:?}", config.rpccookiefile);
-        // info!("  rpcuser: {:?}", config.rpcuser);
-        // info!("  rpcpassword: {:?}", config.rpcpassword);
-        // info!("  delay: {:?}", config.delay);
-        // info!("}}");
-
-        Ok(config)
-    }
-
-    fn check(&self) {
-        if !self.bitcoindir().is_dir() {
-            println!("{:?} isn't a valid directory", self.bitcoindir());
-            println!("Please use the --bitcoindir parameter to set a valid path.");
-            println!("Run the program with '-h' for help.");
-            std::process::exit(1);
-        }
-
-        if !self.blocksdir().is_dir() {
-            println!("{:?} isn't a valid directory", self.blocksdir());
-            println!("Please use the --blocksdir parameter to set a valid path.");
-            println!("Run the program with '-h' for help.");
-            std::process::exit(1);
-        }
-
-        if !self.brkdir().is_dir() {
-            println!("{:?} isn't a valid directory", self.brkdir());
-            println!("Please use the --brkdir parameter to set a valid path.");
-            println!("Run the program with '-h' for help.");
-            std::process::exit(1);
-        }
-
-        if self.rpc_auth().is_err() {
-            println!(
-                "No way found to authenticate the RPC client, please either set --rpccookiefile or --rpcuser and --rpcpassword.\nRun the program with '-h' for help."
-            );
-            std::process::exit(1);
-        }
-    }
-
-    fn read(path: &Path) -> Self {
-        fs::read_to_string(path).map_or_else(
-            |_| RunConfig::default(),
-            |contents| toml::from_str(&contents).unwrap_or_default(),
-        )
-    }
-
-    fn write(&self, path: &Path) -> std::io::Result<()> {
-        fs::write(path, toml::to_string(self).unwrap())
-    }
-
-    pub fn rpc(&self) -> color_eyre::Result<&'static Client> {
-        Ok(Box::leak(Box::new(Client::new(
-            &format!(
-                "http://{}:{}",
-                self.rpcconnect().unwrap_or(&"localhost".to_string()),
-                self.rpcport().unwrap_or(8332)
-            ),
-            self.rpc_auth().unwrap(),
-        )?)))
-    }
-
-    fn rpc_auth(&self) -> color_eyre::Result<Auth> {
-        let cookie = self.path_cookiefile();
-
-        if cookie.is_file() {
-            Ok(Auth::CookieFile(cookie))
-        } else if self.rpcuser.is_some() && self.rpcpassword.is_some() {
-            Ok(Auth::UserPass(
-                self.rpcuser.clone().unwrap(),
-                self.rpcpassword.clone().unwrap(),
-            ))
-        } else {
-            Err(eyre!("Failed to find correct auth"))
-        }
-    }
-
-    fn rpcconnect(&self) -> Option<&String> {
-        self.rpcconnect.as_ref()
-    }
-
-    fn rpcport(&self) -> Option<u16> {
-        self.rpcport
-    }
-
-    pub fn delay(&self) -> Option<u64> {
-        self.delay
-    }
-
-    pub fn bitcoindir(&self) -> PathBuf {
-        self.bitcoindir
-            .as_ref()
-            .map_or_else(default_bitcoin_path, |s| Self::fix_user_path(s.as_ref()))
-    }
-
-    pub fn blocksdir(&self) -> PathBuf {
-        self.blocksdir.as_ref().map_or_else(
-            || self.bitcoindir().join("blocks"),
-            |blocksdir| Self::fix_user_path(blocksdir.as_str()),
-        )
-    }
-
-    pub fn brkdir(&self) -> PathBuf {
-        self.brkdir
-            .as_ref()
-            .map_or_else(default_brk_path, |s| Self::fix_user_path(s.as_ref()))
-    }
-
-    pub fn outputsdir(&self) -> PathBuf {
-        self.brkdir().join("outputs")
-    }
-
-    pub fn harsdir(&self) -> PathBuf {
-        self.outputsdir().join("hars")
-    }
-
-    pub fn process(&self) -> bool {
-        self.mode
-            .is_none_or(|m| m == Mode::All || m == Mode::Processor)
-    }
-
-    pub fn serve(&self) -> bool {
-        self.mode
-            .is_none_or(|m| m == Mode::All || m == Mode::Server)
-    }
-
-    fn path_cookiefile(&self) -> PathBuf {
-        self.rpccookiefile.as_ref().map_or_else(
-            || self.bitcoindir().join(".cookie"),
-            |p| Self::fix_user_path(p.as_str()),
-        )
-    }
-
-    fn fix_user_path(path: &str) -> PathBuf {
-        let fix = move |pattern: &str| {
-            if path.starts_with(pattern) {
-                let path = &path
-                    .replace(&format!("{pattern}/"), "")
-                    .replace(pattern, "");
-
-                let home = std::env::var("HOME").unwrap();
-
-                Some(Path::new(&home).join(path))
+    let mut computer = Computer::forced_import(
+        &config.outputsdir(),
+        &indexer,
+        config.computation(),
+        config.fetcher(),
+        format,
+    )?;
+
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()?
+        .block_on(async {
+            let server = if config.serve() {
+                let served_indexer = indexer.clone();
+                let served_computer = computer.clone();
+
+                let server = Server::new(served_indexer, served_computer, config.website())?;
+
+                let watch = config.watch();
+                let mcp = config.mcp();
+                let opt = Some(tokio::spawn(async move {
+                    server.serve(watch, mcp).await.unwrap();
+                }));
+
+                sleep(Duration::from_secs(1));
+
+                opt
            } else {
                None
+            };
+
+            if config.process() {
+                loop {
+                    wait_for_synced_node()?;
+
+                    let block_count = rpc.get_block_count()?;
+
+                    info!("{} blocks found.", block_count + 1);
+
+                    let starting_indexes =
+                        indexer.index(&parser, rpc, &exit, config.check_collisions())?;
+
+                    computer.compute(&mut indexer, starting_indexes, &exit)?;
+
+                    if let Some(delay) = config.delay() {
+                        sleep(Duration::from_secs(delay))
+                    }
+
+                    info!("Waiting for new blocks...");
+
+                    while block_count == rpc.get_block_count()? {
+                        sleep(Duration::from_secs(1))
+                    }
+                }
            }
-        };

-        fix("~").unwrap_or_else(|| fix("$HOME").unwrap_or_else(|| PathBuf::from(&path)))
-    }
+            if let Some(handle) = server {
+                handle.await.unwrap();
+            }

-    pub fn website(&self) -> Website {
-        self.website.unwrap_or(Website::Default)
-    }
-
-    pub fn fetch(&self) -> bool {
-        self.fetch.is_none_or(|b| b)
-    }
-
-    pub fn fetcher(&self) -> Option<Fetcher> {
-        self.fetch()
-            .then(|| Fetcher::import(Some(self.harsdir().as_path())).unwrap())
-    }
-
-    pub fn computation(&self) -> Computation {
-        self.computation.unwrap_or_default()
-    }
-
-    pub fn format(&self) -> Format {
-        self.format.unwrap_or_default()
-    }
-
-    pub fn check_collisions(&self) -> bool {
-        self.check_collisions.is_some_and(|b| b)
-    }
-}
-
-#[derive(
-    Default,
-    Debug,
-    Clone,
-    Copy,
-    Parser,
-    ValueEnum,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-)]
-pub enum Mode {
-    #[default]
-    All,
-    Processor,
-    Server,
+            Ok(())
+        })
 }
@@ -0,0 +1,23 @@
+use clap_derive::{Parser, ValueEnum};
+use serde::{Deserialize, Serialize};
+
+#[derive(
+    Default,
+    Debug,
+    Clone,
+    Copy,
+    Parser,
+    ValueEnum,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+)]
+pub enum Services {
+    #[default]
+    All,
+    Processor,
+    Server,
+}
@@ -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,17 @@ 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 }
 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"]
@@ -33,17 +33,19 @@ pub fn main() -> color_eyre::Result<()> {

            let format = Format::Raw;

-            let mut indexer = Indexer::new(outputs_dir, format, true)?;
-            indexer.import_stores()?;
-            indexer.import_vecs()?;
+            let mut indexer = Indexer::forced_import(outputs_dir)?;

            let fetcher = Fetcher::import(None)?;

-            let mut computer = Computer::new(outputs_dir, Some(fetcher), format);
-            computer.import_stores(&indexer)?;
-            computer.import_vecs(&indexer, Computation::Lazy)?;
+            let mut computer = Computer::forced_import(
+                outputs_dir,
+                &indexer,
+                Computation::Lazy,
+                Some(fetcher),
+                format,
+            )?;

-            let starting_indexes = indexer.index(&parser, rpc, &exit)?;
+            let starting_indexes = indexer.index(&parser, rpc, &exit, true)?;

            computer.compute(&mut indexer, starting_indexes, &exit)?;

@@ -3,71 +3,60 @@
 #![doc = include_str!("../examples/main.rs")]
 #![doc = "```"]

-use std::path::{Path, PathBuf};
+use std::path::Path;

 use brk_core::Version;
 use brk_exit::Exit;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
-use brk_vec::{AnyCollectableVec, Computation, Format};
+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;

 #[derive(Clone)]
 pub struct Computer {
-    path: PathBuf,
    fetcher: Option<Fetcher>,
-    vecs: Option<Vecs>,
-    stores: Option<Stores>,
-    format: Format,
+    pub vecs: Vecs,
+    pub stores: Stores,
 }

 const VERSION: Version = Version::ONE;

 impl Computer {
-    pub fn new(outputs_dir: &Path, fetcher: Option<Fetcher>, format: Format) -> Self {
-        Self {
-            path: outputs_dir.to_owned(),
-            fetcher,
-            vecs: None,
-            stores: None,
-            format,
-        }
-    }
-
-    pub fn import_vecs(
-        &mut self,
+    /// Do NOT import multiple times or things will break !!!
+    pub fn forced_import(
+        outputs_dir: &Path,
        indexer: &Indexer,
        computation: Computation,
-    ) -> color_eyre::Result<()> {
-        self.vecs = Some(Vecs::import(
-            // TODO: Give self.path, join inside import
-            &self.path.join("vecs/computed"),
-            VERSION + Version::ZERO,
-            indexer,
-            self.fetcher.is_some(),
-            computation,
-            self.format,
-        )?);
-        Ok(())
-    }
-
-    /// Do NOT import multiple times or things will break !!!
-    /// Clone struct instead
-    pub fn import_stores(&mut self, indexer: &Indexer) -> color_eyre::Result<()> {
-        self.stores = Some(Stores::import(
-            // TODO: Give self.path, join inside import
-            &self.path.join("stores"),
-            VERSION + Version::ZERO,
-            indexer.keyspace(),
-        )?);
-        Ok(())
+        fetcher: Option<Fetcher>,
+        format: Format,
+    ) -> color_eyre::Result<Self> {
+        Ok(Self {
+            vecs: Vecs::import(
+                // TODO: Give self.path, join inside import
+                &outputs_dir.join("vecs/computed"),
+                VERSION + Version::ZERO,
+                indexer,
+                fetcher.is_some(),
+                computation,
+                format,
+            )?,
+            stores: Stores::import(
+                // TODO: Give self.path, join inside import
+                &outputs_dir.join("stores"),
+                VERSION + Version::ZERO,
+                &indexer.stores.keyspace,
+            )?,
+            fetcher,
+        })
    }
 }

@@ -79,26 +68,12 @@ impl Computer {
        exit: &Exit,
    ) -> color_eyre::Result<()> {
        info!("Computing...");
-        self.vecs
-            .as_mut()
-            .unwrap()
-            .compute(indexer, starting_indexes, self.fetcher.as_mut(), exit)
-    }
-
-    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
-        // pub fn vecs(&self) -> &Vecs {
-        self.vecs.as_ref().unwrap().vecs()
-    }
-
-    // pub fn mut_vecs(&mut self) -> &mut Vecs {
-    //     self.vecs.as_mut().unwrap()
-    // }
-
-    pub fn stores(&self) -> &Stores {
-        self.stores.as_ref().unwrap()
-    }
-
-    pub fn mut_stores(&mut self) -> &mut Stores {
-        self.stores.as_mut().unwrap()
+        self.vecs.compute(
+            indexer,
+            starting_indexes,
+            self.fetcher.as_mut(),
+            exit,
+            &mut self.stores,
+        )
    }
 }
@@ -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)
+    }
+}
@@ -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);
+                }
            }
        }
    }
@@ -0,0 +1,7 @@
+mod address;
+mod common;
+mod utxo;
+
+pub use address::*;
+pub use common::*;
+pub use utxo::*;
@@ -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()
+    }
+}
@@ -1,19 +1,15 @@
 mod block;
-mod cohort;
-mod outputs;
-mod realized;
-// mod hot;
+mod cohorts;
 mod price_to_amount;
+mod realized;
 mod supply;
 mod transacted;
 mod unrealized;

 pub use block::*;
-pub use cohort::*;
-pub use outputs::*;
-pub use realized::*;
-pub use unrealized::*;
-// pub use hot::*;
+pub use cohorts::*;
 pub use price_to_amount::*;
+pub use realized::*;
 pub use supply::*;
 pub use transacted::*;
+pub use unrealized::*;
@@ -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
-    }
-}
@@ -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) {
@@ -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(),
+        }
+    }
+}
@@ -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;
+    }
+}
@@ -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,
+        ]
+    }
 }
@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::{
    CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, StoredUsize,
@@ -37,8 +37,6 @@ impl Vecs {
        _computation: Computation,
        format: Format,
    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
        Ok(Self {
            height_to_interval: EagerVec::forced_import(
                path,
@@ -154,23 +152,19 @@ impl Vecs {
            starting_indexes,
            exit,
            |v, indexer, _, starting_indexes, exit| {
-                let indexer_vecs = indexer.vecs();
-
                v.compute_range(
                    starting_indexes.height,
-                    &indexer_vecs.height_to_weight,
+                    &indexer.vecs.height_to_weight,
                    |h| (h, StoredU32::from(1_u32)),
                    exit,
                )
            },
        )?;

-        let indexer_vecs = indexer.vecs();
-
-        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
+        let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter();
        self.height_to_interval.compute_transform(
            starting_indexes.height,
-            &indexer_vecs.height_to_timestamp,
+            &indexer.vecs.height_to_timestamp,
            |(height, timestamp, ..)| {
                let interval = height.decremented().map_or(Timestamp::ZERO, |prev_h| {
                    let prev_timestamp = height_to_timestamp_iter.unwrap_get_inner(prev_h);
@@ -194,19 +188,19 @@ impl Vecs {
            indexes,
            starting_indexes,
            exit,
-            Some(&indexer_vecs.height_to_weight),
+            Some(&indexer.vecs.height_to_weight),
        )?;

        self.indexes_to_block_size.compute_rest(
            indexes,
            starting_indexes,
            exit,
-            Some(&indexer_vecs.height_to_total_size),
+            Some(&indexer.vecs.height_to_total_size),
        )?;

        self.height_to_vbytes.compute_transform(
            starting_indexes.height,
-            &indexer_vecs.height_to_weight,
+            &indexer.vecs.height_to_weight,
            |(h, w, ..)| {
                (
                    h,
@@ -223,7 +217,7 @@ impl Vecs {
            Some(&self.height_to_vbytes),
        )?;

-        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
+        let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter();

        self.difficultyepoch_to_timestamp.compute_transform(
            starting_indexes.difficultyepoch,
@@ -0,0 +1,679 @@
+use std::path::Path;
+
+use brk_core::{Bitcoin, CheckedSub, Dollars, StoredF64, Version};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, Computation, Format, VecIterator};
+
+use crate::vecs::{
+    fetched,
+    grouped::{ComputedRatioVecsFromDateIndex, ComputedValueVecsFromHeight},
+    stateful, transactions,
+};
+
+use super::{
+    Indexes,
+    grouped::{ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    indexes,
+};
+
+const VERSION: Version = Version::ZERO;
+
+#[derive(Clone)]
+pub struct Vecs {
+    pub indexes_to_coinblocks_created: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_coinblocks_stored: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_liveliness: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_vaultedness: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_activity_to_vaultedness_ratio: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_vaulted_supply: ComputedValueVecsFromHeight,
+    pub indexes_to_active_supply: ComputedValueVecsFromHeight,
+    pub indexes_to_thermo_cap: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_investor_cap: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_vaulted_cap: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_active_cap: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_vaulted_price: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_vaulted_price_ratio: ComputedRatioVecsFromDateIndex,
+    pub indexes_to_active_price: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_active_price_ratio: ComputedRatioVecsFromDateIndex,
+    pub indexes_to_true_market_mean: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_true_market_mean_ratio: ComputedRatioVecsFromDateIndex,
+    pub indexes_to_cointime_value_destroyed: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_cointime_value_created: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_cointime_value_stored: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_cointime_price: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_cointime_cap: ComputedVecsFromHeight<Dollars>,
+    pub indexes_to_cointime_price_ratio: ComputedRatioVecsFromDateIndex,
+    // pub indexes_to_thermo_cap_relative_to_investor_cap: ComputedValueVecsFromHeight,
+}
+
+impl Vecs {
+    pub fn forced_import(
+        path: &Path,
+        version: Version,
+        _computation: Computation,
+        format: Format,
+        fetched: Option<&fetched::Vecs>,
+    ) -> color_eyre::Result<Self> {
+        let compute_dollars = fetched.is_some();
+
+        Ok(Self {
+            indexes_to_coinblocks_created: ComputedVecsFromHeight::forced_import(
+                path,
+                "coinblocks_created",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
+            )?,
+            indexes_to_coinblocks_stored: ComputedVecsFromHeight::forced_import(
+                path,
+                "coinblocks_stored",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
+            )?,
+            indexes_to_liveliness: ComputedVecsFromHeight::forced_import(
+                path,
+                "liveliness",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_vaultedness: ComputedVecsFromHeight::forced_import(
+                path,
+                "vaultedness",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_activity_to_vaultedness_ratio: ComputedVecsFromHeight::forced_import(
+                path,
+                "activity_to_vaultedness_ratio",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_supply: ComputedValueVecsFromHeight::forced_import(
+                path,
+                "vaulted_supply",
+                true,
+                version + VERSION + Version::ONE,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+                compute_dollars,
+            )?,
+            indexes_to_active_supply: ComputedValueVecsFromHeight::forced_import(
+                path,
+                "active_supply",
+                true,
+                version + VERSION + Version::ONE,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+                compute_dollars,
+            )?,
+            indexes_to_thermo_cap: ComputedVecsFromHeight::forced_import(
+                path,
+                "thermo_cap",
+                true,
+                version + VERSION + Version::ONE,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_investor_cap: ComputedVecsFromHeight::forced_import(
+                path,
+                "investor_cap",
+                true,
+                version + VERSION + Version::ONE,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_cap: ComputedVecsFromHeight::forced_import(
+                path,
+                "vaulted_cap",
+                true,
+                version + VERSION + Version::ONE,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_active_cap: ComputedVecsFromHeight::forced_import(
+                path,
+                "active_cap",
+                true,
+                version + VERSION + Version::ONE,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_price: ComputedVecsFromHeight::forced_import(
+                path,
+                "vaulted_price",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                path,
+                "vaulted_price",
+                false,
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+            indexes_to_active_price: ComputedVecsFromHeight::forced_import(
+                path,
+                "active_price",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_active_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                path,
+                "active_price",
+                false,
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+            indexes_to_true_market_mean: ComputedVecsFromHeight::forced_import(
+                path,
+                "true_market_mean",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_true_market_mean_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                path,
+                "true_market_mean",
+                false,
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+            indexes_to_cointime_value_destroyed: ComputedVecsFromHeight::forced_import(
+                path,
+                "cointime_value_destroyed",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
+            )?,
+            indexes_to_cointime_value_created: ComputedVecsFromHeight::forced_import(
+                path,
+                "cointime_value_created",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
+            )?,
+            indexes_to_cointime_value_stored: ComputedVecsFromHeight::forced_import(
+                path,
+                "cointime_value_stored",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
+            )?,
+            indexes_to_cointime_price: ComputedVecsFromHeight::forced_import(
+                path,
+                "cointime_price",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_cointime_cap: ComputedVecsFromHeight::forced_import(
+                path,
+                "cointime_cap",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_cointime_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                path,
+                "cointime_price",
+                false,
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        fetched: Option<&fetched::Vecs>,
+        transactions: &transactions::Vecs,
+        stateful: &stateful::Vecs,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        let circulating_supply = &stateful.utxo_vecs.all.1.height_to_supply;
+
+        self.indexes_to_coinblocks_created.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_transform(
+                    starting_indexes.height,
+                    circulating_supply,
+                    |(i, v, ..)| (i, StoredF64::from(Bitcoin::from(v))),
+                    exit,
+                )
+            },
+        )?;
+
+        let indexes_to_coinblocks_destroyed =
+            &stateful.utxo_vecs.all.1.indexes_to_coinblocks_destroyed;
+
+        self.indexes_to_coinblocks_stored.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                let mut coinblocks_destroyed_iter = indexes_to_coinblocks_destroyed
+                    .height
+                    .as_ref()
+                    .unwrap()
+                    .into_iter();
+                vec.compute_transform(
+                    starting_indexes.height,
+                    self.indexes_to_coinblocks_created.height.as_ref().unwrap(),
+                    |(i, created, ..)| {
+                        let destroyed = coinblocks_destroyed_iter.unwrap_get_inner(i);
+                        (i, created.checked_sub(destroyed).unwrap())
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_liveliness.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_divide(
+                    starting_indexes.height,
+                    indexes_to_coinblocks_destroyed
+                        .height_extra
+                        .unwrap_cumulative(),
+                    self.indexes_to_coinblocks_created
+                        .height_extra
+                        .unwrap_cumulative(),
+                    exit,
+                )
+            },
+        )?;
+        let liveliness = &self.indexes_to_liveliness;
+
+        self.indexes_to_vaultedness.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_transform(
+                    starting_indexes.height,
+                    liveliness.height.as_ref().unwrap(),
+                    |(i, v, ..)| (i, StoredF64::from(1.0).checked_sub(v).unwrap()),
+                    exit,
+                )
+            },
+        )?;
+        let vaultedness = &self.indexes_to_vaultedness;
+
+        self.indexes_to_activity_to_vaultedness_ratio.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_divide(
+                    starting_indexes.height,
+                    liveliness.height.as_ref().unwrap(),
+                    vaultedness.height.as_ref().unwrap(),
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_vaulted_supply.compute_all(
+            indexer,
+            indexes,
+            fetched,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_multiply(
+                    starting_indexes.height,
+                    circulating_supply,
+                    vaultedness.height.as_ref().unwrap(),
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_active_supply.compute_all(
+            indexer,
+            indexes,
+            fetched,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_multiply(
+                    starting_indexes.height,
+                    circulating_supply,
+                    liveliness.height.as_ref().unwrap(),
+                    exit,
+                )
+            },
+        )?;
+
+        if let Some(fetched) = fetched {
+            let realized_cap = stateful
+                .utxo_vecs
+                .all
+                .1
+                .height_to_realized_cap
+                .as_ref()
+                .unwrap();
+
+            let realized_price = stateful
+                .utxo_vecs
+                .all
+                .1
+                .indexes_to_realized_price
+                .as_ref()
+                .unwrap()
+                .height
+                .as_ref()
+                .unwrap();
+
+            self.indexes_to_thermo_cap.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_transform(
+                        starting_indexes.height,
+                        transactions
+                            .indexes_to_subsidy
+                            .dollars
+                            .as_ref()
+                            .unwrap()
+                            .height_extra
+                            .unwrap_cumulative(),
+                        |(i, v, ..)| (i, v),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_investor_cap.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_subtract(
+                        starting_indexes.height,
+                        realized_cap,
+                        self.indexes_to_thermo_cap.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_vaulted_cap.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_divide(
+                        starting_indexes.height,
+                        realized_cap,
+                        self.indexes_to_vaultedness.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_active_cap.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        realized_cap,
+                        self.indexes_to_liveliness.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_vaulted_price.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_divide(
+                        starting_indexes.height,
+                        realized_price,
+                        self.indexes_to_vaultedness.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_vaulted_price_ratio.compute_rest(
+                indexer,
+                indexes,
+                fetched,
+                starting_indexes,
+                exit,
+                Some(self.indexes_to_vaulted_price.dateindex.unwrap_last()),
+            )?;
+
+            self.indexes_to_active_price.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        realized_price,
+                        self.indexes_to_liveliness.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_active_price_ratio.compute_rest(
+                indexer,
+                indexes,
+                fetched,
+                starting_indexes,
+                exit,
+                Some(self.indexes_to_active_price.dateindex.unwrap_last()),
+            )?;
+
+            self.indexes_to_true_market_mean.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_divide(
+                        starting_indexes.height,
+                        self.indexes_to_investor_cap.height.as_ref().unwrap(),
+                        self.indexes_to_active_supply
+                            .bitcoin
+                            .height
+                            .as_ref()
+                            .unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_true_market_mean_ratio.compute_rest(
+                indexer,
+                indexes,
+                fetched,
+                starting_indexes,
+                exit,
+                Some(self.indexes_to_true_market_mean.dateindex.unwrap_last()),
+            )?;
+
+            self.indexes_to_cointime_value_destroyed.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    // TODO: Another example when the callback should be applied to each index, instead of to base then merging from more granular to less
+                    // The price taken won't be correct for time based indexes
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        &fetched.chainindexes_to_close.height,
+                        indexes_to_coinblocks_destroyed.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_cointime_value_created.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        &fetched.chainindexes_to_close.height,
+                        self.indexes_to_coinblocks_created.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_cointime_value_stored.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        &fetched.chainindexes_to_close.height,
+                        self.indexes_to_coinblocks_stored.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_cointime_price.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_divide(
+                        starting_indexes.height,
+                        self.indexes_to_cointime_value_destroyed
+                            .height_extra
+                            .unwrap_cumulative(),
+                        self.indexes_to_coinblocks_stored
+                            .height_extra
+                            .unwrap_cumulative(),
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_cointime_cap.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        self.indexes_to_cointime_price.height.as_ref().unwrap(),
+                        circulating_supply,
+                        exit,
+                    )
+                },
+            )?;
+
+            self.indexes_to_cointime_price_ratio.compute_rest(
+                indexer,
+                indexes,
+                fetched,
+                starting_indexes,
+                exit,
+                Some(self.indexes_to_cointime_price.dateindex.unwrap_last()),
+            )?;
+        }
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.indexes_to_coinblocks_created.vecs(),
+            self.indexes_to_coinblocks_stored.vecs(),
+            self.indexes_to_liveliness.vecs(),
+            self.indexes_to_vaultedness.vecs(),
+            self.indexes_to_activity_to_vaultedness_ratio.vecs(),
+            self.indexes_to_vaulted_supply.vecs(),
+            self.indexes_to_active_supply.vecs(),
+            self.indexes_to_thermo_cap.vecs(),
+            self.indexes_to_investor_cap.vecs(),
+            self.indexes_to_vaulted_cap.vecs(),
+            self.indexes_to_active_cap.vecs(),
+            self.indexes_to_vaulted_price.vecs(),
+            self.indexes_to_vaulted_price_ratio.vecs(),
+            self.indexes_to_active_price.vecs(),
+            self.indexes_to_active_price_ratio.vecs(),
+            self.indexes_to_true_market_mean.vecs(),
+            self.indexes_to_true_market_mean_ratio.vecs(),
+            self.indexes_to_cointime_price.vecs(),
+            self.indexes_to_cointime_cap.vecs(),
+            self.indexes_to_cointime_price_ratio.vecs(),
+            self.indexes_to_cointime_value_destroyed.vecs(),
+            self.indexes_to_cointime_value_created.vecs(),
+            self.indexes_to_cointime_value_stored.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}
@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::{StoredU8, Version};
 use brk_exit::Exit;
@@ -15,10 +15,10 @@ const VERSION: Version = Version::ZERO;

 #[derive(Clone)]
 pub struct Vecs {
-    pub _0: ComputedVecsFromHeight<StoredU8>,
-    pub _1: ComputedVecsFromHeight<StoredU8>,
-    pub _50: ComputedVecsFromHeight<StoredU8>,
-    pub _100: ComputedVecsFromHeight<StoredU8>,
+    pub constant_0: ComputedVecsFromHeight<StoredU8>,
+    pub constant_1: ComputedVecsFromHeight<StoredU8>,
+    pub constant_50: ComputedVecsFromHeight<StoredU8>,
+    pub constant_100: ComputedVecsFromHeight<StoredU8>,
 }

 impl Vecs {
@@ -28,36 +28,34 @@ impl Vecs {
        _computation: Computation,
        format: Format,
    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
        Ok(Self {
-            _0: ComputedVecsFromHeight::forced_import(
+            constant_0: ComputedVecsFromHeight::forced_import(
                path,
-                "0",
+                "constant_0",
                true,
                version + VERSION + Version::ZERO,
                format,
                StorableVecGeneatorOptions::default().add_last(),
            )?,
-            _1: ComputedVecsFromHeight::forced_import(
+            constant_1: ComputedVecsFromHeight::forced_import(
                path,
-                "1",
+                "constant_1",
                true,
                version + VERSION + Version::ZERO,
                format,
                StorableVecGeneatorOptions::default().add_last(),
            )?,
-            _50: ComputedVecsFromHeight::forced_import(
+            constant_50: ComputedVecsFromHeight::forced_import(
                path,
-                "50",
+                "constant_50",
                true,
                version + VERSION + Version::ZERO,
                format,
                StorableVecGeneatorOptions::default().add_last(),
            )?,
-            _100: ComputedVecsFromHeight::forced_import(
+            constant_100: ComputedVecsFromHeight::forced_import(
                path,
-                "100",
+                "constant_100",
                true,
                version + VERSION + Version::ZERO,
                format,
@@ -73,7 +71,7 @@ impl Vecs {
        starting_indexes: &Indexes,
        exit: &Exit,
    ) -> color_eyre::Result<()> {
-        self._0.compute_all(
+        self.constant_0.compute_all(
            indexer,
            indexes,
            starting_indexes,
@@ -89,7 +87,7 @@ impl Vecs {
            },
        )?;

-        self._1.compute_all(
+        self.constant_1.compute_all(
            indexer,
            indexes,
            starting_indexes,
@@ -105,7 +103,7 @@ impl Vecs {
            },
        )?;

-        self._50.compute_all(
+        self.constant_50.compute_all(
            indexer,
            indexes,
            starting_indexes,
@@ -121,7 +119,7 @@ impl Vecs {
            },
        )?;

-        self._100.compute_all(
+        self.constant_100.compute_all(
            indexer,
            indexes,
            starting_indexes,
@@ -142,10 +140,10 @@ impl Vecs {

    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
        [
-            self._0.vecs(),
-            self._1.vecs(),
-            self._50.vecs(),
-            self._100.vecs(),
+            self.constant_0.vecs(),
+            self.constant_1.vecs(),
+            self.constant_50.vecs(),
+            self.constant_100.vecs(),
        ]
        .into_iter()
        .flatten()
@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::{
    Cents, Close, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, High, Low, MonthIndex,
@@ -7,7 +7,7 @@ use brk_core::{
 use brk_exit::Exit;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
-use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, EagerVec, Format};
+use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, EagerVec, Format, StoredIndex};

 use super::{
    Indexes,
@@ -75,8 +75,6 @@ impl Vecs {
        _computation: Computation,
        format: Format,
    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
        let mut fetched_path = path.to_owned();
        fetched_path.pop();
        fetched_path = fetched_path.join("fetched");
@@ -371,12 +369,10 @@ impl Vecs {
        fetcher: &mut Fetcher,
        exit: &Exit,
    ) -> color_eyre::Result<()> {
-        let indexer_vecs = indexer.vecs();
-
-        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
+        let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter();
        self.height_to_ohlc_in_cents.compute_transform(
            starting_indexes.height,
-            &indexer_vecs.height_to_timestamp,
+            &indexer.vecs.height_to_timestamp,
            |(h, t, ..)| {
                let ohlc = fetcher
                    .get_height(
@@ -429,8 +425,24 @@ impl Vecs {
        self.dateindex_to_ohlc_in_cents.compute_transform(
            starting_indexes.dateindex,
            &indexes.dateindex_to_date,
-            |(di, d, ..)| {
-                let ohlc = fetcher.get_date(d).unwrap();
+            |(di, d, this)| {
+                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())
+                        .unwrap()
+                        .unwrap()
+                        .close;
+                    *ohlc.open = prev_open;
+                    *ohlc.high = (*ohlc.high).max(prev_open);
+                    *ohlc.low = (*ohlc.low).min(prev_open);
+                }
                (di, ohlc)
            },
            exit,
@@ -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,11 @@ where
                Box::new(
                    EagerVec::forced_import(
                        path,
-                        &maybe_suffix("sum"),
+                        &(if !options.last && !options.average && !options.min && !options.max {
+                            name.to_string()
+                        } else {
+                            maybe_suffix("sum")
+                        }),
                        version + VERSION + Version::ZERO,
                        format,
                    )
@@ -141,7 +135,7 @@ where
                Box::new(
                    EagerVec::forced_import(
                        path,
-                        &prefix("cumulative"),
+                        &suffix("cumulative"),
                        version + VERSION + Version::ZERO,
                        format,
                    )
@@ -217,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)
        })?;

@@ -257,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);

@@ -280,7 +274,7 @@ where
                    //     dbg!(first_index, count_index, last_index);
                    // })
                    // .unwrap()
-                    // .into_inner();
+                    // .into_owned();
                    last.forced_push_at(index, v, exit)?;
                }

@@ -300,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 {
@@ -431,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);

@@ -469,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)?;
@@ -480,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)?;
@@ -493,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();
@@ -509,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);
@@ -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)?;

@@ -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};

@@ -163,7 +163,7 @@ where
            self.height.compute(
                starting_indexes.height,
                txindex,
-                &indexer.vecs().height_to_first_txindex,
+                &indexer.vecs.height_to_first_txindex,
                &indexes.height_to_txindex_count,
                exit,
            )?;
@@ -173,7 +173,7 @@ where
            self.height.compute(
                starting_indexes.height,
                txindex,
-                &indexer.vecs().height_to_first_txindex,
+                &indexer.vecs.height_to_first_txindex,
                &indexes.height_to_txindex_count,
                exit,
            )?;
@@ -289,7 +289,7 @@ impl ComputedVecsFromTxindex<Bitcoin> {

        let starting_index = self.height.starting_index(starting_indexes.height);

-        (starting_index.unwrap_to_usize()..indexer.vecs().height_to_weight.len())
+        (starting_index.unwrap_to_usize()..indexer.vecs.height_to_weight.len())
            .map(Height::from)
            .try_for_each(|height| -> Result<()> {
                if let Some(first) = self.height.first.as_mut() {
@@ -470,7 +470,7 @@ impl ComputedVecsFromTxindex<Dollars> {

        let mut close_iter = fetched.chainindexes_to_close.height.into_iter();

-        (starting_index.unwrap_to_usize()..indexer.vecs().height_to_weight.len())
+        (starting_index.unwrap_to_usize()..indexer.vecs.height_to_weight.len())
            .map(Height::from)
            .try_for_each(|height| -> Result<()> {
                let price = *close_iter.unwrap_get_inner(height);
@@ -24,8 +24,11 @@ pub struct ComputedRatioVecsFromDateIndex {
    pub ratio_1w_sma: ComputedVecsFromDateIndex<StoredF32>,
    pub ratio_1m_sma: ComputedVecsFromDateIndex<StoredF32>,
    pub ratio_1y_sma: ComputedVecsFromDateIndex<StoredF32>,
+    pub ratio_4y_sma: ComputedVecsFromDateIndex<StoredF32>,
    pub ratio_1y_sma_momentum_oscillator: ComputedVecsFromDateIndex<StoredF32>,
-    pub ratio_standard_deviation: ComputedVecsFromDateIndex<StoredF32>,
+    pub ratio_sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub ratio_4y_sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub ratio_1y_sd: ComputedVecsFromDateIndex<StoredF32>,
    pub ratio_p99_9: ComputedVecsFromDateIndex<StoredF32>,
    pub ratio_p99_5: ComputedVecsFromDateIndex<StoredF32>,
    pub ratio_p99: ComputedVecsFromDateIndex<StoredF32>,
@@ -51,6 +54,8 @@ pub struct ComputedRatioVecsFromDateIndex {
    pub ratio_m2sd_as_price: ComputedVecsFromDateIndex<Dollars>,
    pub ratio_m3sd_as_price: ComputedVecsFromDateIndex<Dollars>,
    pub ratio_zscore: ComputedVecsFromDateIndex<StoredF32>,
+    pub ratio_4y_zscore: ComputedVecsFromDateIndex<StoredF32>,
+    pub ratio_1y_zscore: ComputedVecsFromDateIndex<StoredF32>,
 }

 const VERSION: Version = Version::ZERO;
@@ -62,8 +67,9 @@ impl ComputedRatioVecsFromDateIndex {
        compute_source: bool,
        version: Version,
        format: Format,
-        options: StorableVecGeneatorOptions,
    ) -> color_eyre::Result<Self> {
+        let options = StorableVecGeneatorOptions::default().add_last();
+
        Ok(Self {
            price: compute_source.then(|| {
                ComputedVecsFromDateIndex::forced_import(
@@ -116,6 +122,14 @@ impl ComputedRatioVecsFromDateIndex {
                format,
                options,
            )?,
+            ratio_4y_sma: ComputedVecsFromDateIndex::forced_import(
+                path,
+                &format!("{name}_ratio_4y_sma"),
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
            ratio_1y_sma_momentum_oscillator: ComputedVecsFromDateIndex::forced_import(
                path,
                &format!("{name}_ratio_1y_sma_momentum_oscillator"),
@@ -124,9 +138,25 @@ impl ComputedRatioVecsFromDateIndex {
                format,
                options,
            )?,
-            ratio_standard_deviation: ComputedVecsFromDateIndex::forced_import(
+            ratio_sd: ComputedVecsFromDateIndex::forced_import(
                path,
-                &format!("{name}_ratio_standard_deviation"),
+                &format!("{name}_ratio_sd"),
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            ratio_4y_sd: ComputedVecsFromDateIndex::forced_import(
+                path,
+                &format!("{name}_ratio_4y_sd"),
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            ratio_1y_sd: ComputedVecsFromDateIndex::forced_import(
+                path,
+                &format!("{name}_ratio_1y_sd"),
                true,
                version + VERSION + Version::ZERO,
                format,
@@ -332,6 +362,22 @@ impl ComputedRatioVecsFromDateIndex {
                format,
                options,
            )?,
+            ratio_4y_zscore: ComputedVecsFromDateIndex::forced_import(
+                path,
+                &format!("{name}_ratio_4y_zscore"),
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            ratio_1y_zscore: ComputedVecsFromDateIndex::forced_import(
+                path,
+                &format!("{name}_ratio_1y_zscore"),
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
        })
    }

@@ -476,6 +522,22 @@ impl ComputedRatioVecsFromDateIndex {
            },
        )?;

+        self.ratio_4y_sma.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_sma_(
+                    starting_indexes.dateindex,
+                    self.ratio.dateindex.as_ref().unwrap(),
+                    4 * 365,
+                    exit,
+                    Some(min_ratio_date),
+                )
+            },
+        )?;
+
        self.ratio_1y_sma_momentum_oscillator.compute_all(
            indexer,
            indexes,
@@ -527,6 +589,8 @@ impl ComputedRatioVecsFromDateIndex {
        // }

        let mut sma_iter = self.ratio_sma.dateindex.as_ref().unwrap().into_iter();
+        let mut _4y_sma_iter = self.ratio_4y_sma.dateindex.as_ref().unwrap().into_iter();
+        let mut _1y_sma_iter = self.ratio_1y_sma.dateindex.as_ref().unwrap().into_iter();

        let nan = StoredF32::from(f32::NAN);
        self.ratio
@@ -566,7 +630,17 @@ impl ComputedRatioVecsFromDateIndex {
                        .as_mut()
                        .unwrap()
                        .forced_push_at(index, nan, exit)?;
-                    self.ratio_standard_deviation
+                    self.ratio_sd
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, nan, exit)?;
+                    self.ratio_4y_sd
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, nan, exit)?;
+                    self.ratio_1y_sd
                        .dateindex
                        .as_mut()
                        .unwrap()
@@ -603,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(
@@ -645,12 +719,40 @@ impl ComputedRatioVecsFromDateIndex {
                            .sqrt(),
                    );

-                    self.ratio_standard_deviation
+                    self.ratio_sd
                        .dateindex
                        .as_mut()
                        .unwrap()
                        .forced_push_at(index, sd, exit)?;

+                    let _4y_avg = _4y_sma_iter.unwrap_get_inner(index);
+
+                    let _4y_sd = StoredF32::from(
+                        (sorted.iter().map(|v| (**v - *_4y_avg).powi(2)).sum::<f32>()
+                            / (index.unwrap_to_usize() + 1) as f32)
+                            .sqrt(),
+                    );
+
+                    self.ratio_4y_sd
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, _4y_sd, exit)?;
+
+                    let _1y_avg = _1y_sma_iter.unwrap_get_inner(index);
+
+                    let _1y_sd = StoredF32::from(
+                        (sorted.iter().map(|v| (**v - *_1y_avg).powi(2)).sum::<f32>()
+                            / (index.unwrap_to_usize() + 1) as f32)
+                            .sqrt(),
+                    );
+
+                    self.ratio_1y_sd
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, _1y_sd, exit)?;
+
                    self.ratio_p1sd.dateindex.as_mut().unwrap().forced_push_at(
                        index,
                        avg + sd,
@@ -726,7 +828,19 @@ impl ComputedRatioVecsFromDateIndex {
            exit,
            None as Option<&EagerVec<_, _>>,
        )?;
-        self.ratio_standard_deviation.compute_rest(
+        self.ratio_sd.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+        self.ratio_4y_sd.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+        self.ratio_1y_sd.compute_rest(
            indexes,
            starting_indexes,
            exit,
@@ -1007,21 +1121,43 @@ impl ComputedRatioVecsFromDateIndex {
            starting_indexes,
            exit,
            |vec, _, _, starting_indexes, exit| {
-                let mut sma_iter = self.ratio_sma.dateindex.as_ref().unwrap().into_iter();
-                let mut sd_iter = self
-                    .ratio_standard_deviation
-                    .dateindex
-                    .as_ref()
-                    .unwrap()
-                    .into_iter();
-                vec.compute_transform(
+                vec.compute_zscore(
                    starting_indexes.dateindex,
                    self.ratio.dateindex.as_ref().unwrap(),
-                    |(i, ratio, ..)| {
-                        let sma = sma_iter.unwrap_get_inner(i);
-                        let sd = sd_iter.unwrap_get_inner(i);
-                        (i, (ratio - sma) / sd)
-                    },
+                    self.ratio_sma.dateindex.as_ref().unwrap(),
+                    self.ratio_sd.dateindex.as_ref().unwrap(),
+                    exit,
+                )
+            },
+        )?;
+
+        self.ratio_4y_zscore.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_zscore(
+                    starting_indexes.dateindex,
+                    self.ratio.dateindex.as_ref().unwrap(),
+                    self.ratio_4y_sma.dateindex.as_ref().unwrap(),
+                    self.ratio_4y_sd.dateindex.as_ref().unwrap(),
+                    exit,
+                )
+            },
+        )?;
+
+        self.ratio_1y_zscore.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_zscore(
+                    starting_indexes.dateindex,
+                    self.ratio.dateindex.as_ref().unwrap(),
+                    self.ratio_1y_sma.dateindex.as_ref().unwrap(),
+                    self.ratio_1y_sd.dateindex.as_ref().unwrap(),
                    exit,
                )
            },
@@ -1032,7 +1168,9 @@ impl ComputedRatioVecsFromDateIndex {

    fn mut_ratio_vecs(&mut self) -> Vec<&mut EagerVec<DateIndex, StoredF32>> {
        vec![
-            self.ratio_standard_deviation.dateindex.as_mut().unwrap(),
+            self.ratio_sd.dateindex.as_mut().unwrap(),
+            self.ratio_4y_sd.dateindex.as_mut().unwrap(),
+            self.ratio_1y_sd.dateindex.as_mut().unwrap(),
            self.ratio_p99_9.dateindex.as_mut().unwrap(),
            self.ratio_p99_5.dateindex.as_mut().unwrap(),
            self.ratio_p99.dateindex.as_mut().unwrap(),
@@ -1056,8 +1194,11 @@ impl ComputedRatioVecsFromDateIndex {
            self.ratio_1w_sma.vecs(),
            self.ratio_1m_sma.vecs(),
            self.ratio_1y_sma.vecs(),
+            self.ratio_4y_sma.vecs(),
            self.ratio_1y_sma_momentum_oscillator.vecs(),
-            self.ratio_standard_deviation.vecs(),
+            self.ratio_sd.vecs(),
+            self.ratio_1y_sd.vecs(),
+            self.ratio_4y_sd.vecs(),
            self.ratio_p99_9.vecs(),
            self.ratio_p99_5.vecs(),
            self.ratio_p99.vecs(),
@@ -1083,6 +1224,8 @@ impl ComputedRatioVecsFromDateIndex {
            self.ratio_m2sd_as_price.vecs(),
            self.ratio_m3sd_as_price.vecs(),
            self.ratio_zscore.vecs(),
+            self.ratio_1y_zscore.vecs(),
+            self.ratio_4y_zscore.vecs(),
        ]
        .into_iter()
        .flatten()
@@ -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)
                            })
                    })
                },
@@ -205,7 +205,7 @@ impl ComputedValueVecsFromTxindex {

            dollars_txindex.compute_if_necessary(
                starting_indexes.txindex,
-                &indexer.vecs().txindex_to_txid,
+                &indexer.vecs.txindex_to_txid,
                exit,
            )?;

@@ -226,7 +226,11 @@ impl ComputedValueVecsFromTxindex {
    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
        [
            self.sats.vecs(),
+            vec![&self.bitcoin_txindex as &dyn AnyCollectableVec],
            self.bitcoin.vecs(),
+            self.dollars_txindex
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
            self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
        ]
        .into_iter()
@@ -1,11 +1,12 @@
-use std::{fs, ops::Deref, path::Path};
+use std::{ops::Deref, path::Path};

 use brk_core::{
    Date, DateIndex, DecadeIndex, DifficultyEpoch, EmptyOutputIndex, HalvingEpoch, Height,
-    InputIndex, MonthIndex, OpReturnIndex, OutputIndex, P2ABytes, P2AIndex, P2MSIndex, P2PK33Bytes,
-    P2PK33Index, P2PK65Bytes, P2PK65Index, P2PKHBytes, P2PKHIndex, P2SHBytes, P2SHIndex, P2TRBytes,
-    P2TRIndex, P2WPKHBytes, P2WPKHIndex, P2WSHBytes, P2WSHIndex, QuarterIndex, Sats, StoredUsize,
-    Timestamp, TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, YearIndex,
+    InputIndex, MonthIndex, OpReturnIndex, OutputIndex, P2AAddressIndex, P2ABytes, P2MSOutputIndex,
+    P2PK33AddressIndex, P2PK33Bytes, P2PK65AddressIndex, P2PK65Bytes, P2PKHAddressIndex,
+    P2PKHBytes, P2SHAddressIndex, P2SHBytes, P2TRAddressIndex, P2TRBytes, P2WPKHAddressIndex,
+    P2WPKHBytes, P2WSHAddressIndex, P2WSHBytes, QuarterIndex, Sats, StoredUsize, Timestamp,
+    TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, YearIndex,
 };
 use brk_exit::Exit;
 use brk_indexer::Indexer;
@@ -54,18 +55,24 @@ pub struct Vecs {
        ComputedVecFrom1<OpReturnIndex, OpReturnIndex, OpReturnIndex, TxIndex>,
    pub outputindex_to_outputindex: ComputedVecFrom1<OutputIndex, OutputIndex, OutputIndex, Sats>,
    pub outputindex_to_txindex: EagerVec<OutputIndex, TxIndex>,
-    pub p2aindex_to_p2aindex: ComputedVecFrom1<P2AIndex, P2AIndex, P2AIndex, P2ABytes>,
-    pub p2msindex_to_p2msindex: ComputedVecFrom1<P2MSIndex, P2MSIndex, P2MSIndex, TxIndex>,
-    pub p2pk33index_to_p2pk33index:
-        ComputedVecFrom1<P2PK33Index, P2PK33Index, P2PK33Index, P2PK33Bytes>,
-    pub p2pk65index_to_p2pk65index:
-        ComputedVecFrom1<P2PK65Index, P2PK65Index, P2PK65Index, P2PK65Bytes>,
-    pub p2pkhindex_to_p2pkhindex: ComputedVecFrom1<P2PKHIndex, P2PKHIndex, P2PKHIndex, P2PKHBytes>,
-    pub p2shindex_to_p2shindex: ComputedVecFrom1<P2SHIndex, P2SHIndex, P2SHIndex, P2SHBytes>,
-    pub p2trindex_to_p2trindex: ComputedVecFrom1<P2TRIndex, P2TRIndex, P2TRIndex, P2TRBytes>,
-    pub p2wpkhindex_to_p2wpkhindex:
-        ComputedVecFrom1<P2WPKHIndex, P2WPKHIndex, P2WPKHIndex, P2WPKHBytes>,
-    pub p2wshindex_to_p2wshindex: ComputedVecFrom1<P2WSHIndex, P2WSHIndex, P2WSHIndex, P2WSHBytes>,
+    pub p2aaddressindex_to_p2aaddressindex:
+        ComputedVecFrom1<P2AAddressIndex, P2AAddressIndex, P2AAddressIndex, P2ABytes>,
+    pub p2msoutputindex_to_p2msoutputindex:
+        ComputedVecFrom1<P2MSOutputIndex, P2MSOutputIndex, P2MSOutputIndex, TxIndex>,
+    pub p2pk33addressindex_to_p2pk33addressindex:
+        ComputedVecFrom1<P2PK33AddressIndex, P2PK33AddressIndex, P2PK33AddressIndex, P2PK33Bytes>,
+    pub p2pk65addressindex_to_p2pk65addressindex:
+        ComputedVecFrom1<P2PK65AddressIndex, P2PK65AddressIndex, P2PK65AddressIndex, P2PK65Bytes>,
+    pub p2pkhaddressindex_to_p2pkhaddressindex:
+        ComputedVecFrom1<P2PKHAddressIndex, P2PKHAddressIndex, P2PKHAddressIndex, P2PKHBytes>,
+    pub p2shaddressindex_to_p2shaddressindex:
+        ComputedVecFrom1<P2SHAddressIndex, P2SHAddressIndex, P2SHAddressIndex, P2SHBytes>,
+    pub p2traddressindex_to_p2traddressindex:
+        ComputedVecFrom1<P2TRAddressIndex, P2TRAddressIndex, P2TRAddressIndex, P2TRBytes>,
+    pub p2wpkhaddressindex_to_p2wpkhaddressindex:
+        ComputedVecFrom1<P2WPKHAddressIndex, P2WPKHAddressIndex, P2WPKHAddressIndex, P2WPKHBytes>,
+    pub p2wshaddressindex_to_p2wshaddressindex:
+        ComputedVecFrom1<P2WSHAddressIndex, P2WSHAddressIndex, P2WSHAddressIndex, P2WSHBytes>,
    pub quarterindex_to_first_monthindex: EagerVec<QuarterIndex, MonthIndex>,
    pub quarterindex_to_monthindex_count: EagerVec<QuarterIndex, StoredUsize>,
    pub quarterindex_to_quarterindex: EagerVec<QuarterIndex, QuarterIndex>,
@@ -94,15 +101,13 @@ impl Vecs {
        computation: Computation,
        format: Format,
    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
        let outputindex_to_outputindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
            "outputindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().outputindex_to_value.boxed_clone(),
+            indexer.vecs.outputindex_to_value.boxed_clone(),
            |index, _| Some(index),
        )?;

@@ -112,7 +117,7 @@ impl Vecs {
            "inputindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().inputindex_to_outputindex.boxed_clone(),
+            indexer.vecs.inputindex_to_outputindex.boxed_clone(),
            |index, _| Some(index),
        )?;

@@ -122,7 +127,7 @@ impl Vecs {
            "txindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().txindex_to_txid.boxed_clone(),
+            indexer.vecs.txindex_to_txid.boxed_clone(),
            |index, _| Some(index),
        )?;

@@ -132,17 +137,17 @@ impl Vecs {
            "input_count",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().txindex_to_first_inputindex.boxed_clone(),
-            indexer.vecs().inputindex_to_outputindex.boxed_clone(),
+            indexer.vecs.txindex_to_first_inputindex.boxed_clone(),
+            indexer.vecs.inputindex_to_outputindex.boxed_clone(),
            |index: TxIndex, txindex_to_first_inputindex_iter, inputindex_to_outputindex_iter| {
                let txindex = index.unwrap_to_usize();
                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())
                    })
@@ -155,102 +160,102 @@ impl Vecs {
            "output_count",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().txindex_to_first_outputindex.boxed_clone(),
-            indexer.vecs().outputindex_to_value.boxed_clone(),
+            indexer.vecs.txindex_to_first_outputindex.boxed_clone(),
+            indexer.vecs.outputindex_to_value.boxed_clone(),
            |index: TxIndex, txindex_to_first_outputindex_iter, outputindex_to_value_iter| {
                let txindex = index.unwrap_to_usize();
                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())
                    })
            },
        )?;

-        let p2pk33index_to_p2pk33index = ComputedVec::forced_import_or_init_from_1(
+        let p2pk33addressindex_to_p2pk33addressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2pk33index",
+            "p2pk33addressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2pk33index_to_p2pk33bytes.boxed_clone(),
+            indexer.vecs.p2pk33addressindex_to_p2pk33bytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2pk65index_to_p2pk65index = ComputedVec::forced_import_or_init_from_1(
+        let p2pk65addressindex_to_p2pk65addressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2pk65index",
+            "p2pk65addressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2pk65index_to_p2pk65bytes.boxed_clone(),
+            indexer.vecs.p2pk65addressindex_to_p2pk65bytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2pkhindex_to_p2pkhindex = ComputedVec::forced_import_or_init_from_1(
+        let p2pkhaddressindex_to_p2pkhaddressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2pkhindex",
+            "p2pkhaddressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2pkhindex_to_p2pkhbytes.boxed_clone(),
+            indexer.vecs.p2pkhaddressindex_to_p2pkhbytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2shindex_to_p2shindex = ComputedVec::forced_import_or_init_from_1(
+        let p2shaddressindex_to_p2shaddressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2shindex",
+            "p2shaddressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2shindex_to_p2shbytes.boxed_clone(),
+            indexer.vecs.p2shaddressindex_to_p2shbytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2trindex_to_p2trindex = ComputedVec::forced_import_or_init_from_1(
+        let p2traddressindex_to_p2traddressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2trindex",
+            "p2traddressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2trindex_to_p2trbytes.boxed_clone(),
+            indexer.vecs.p2traddressindex_to_p2trbytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2wpkhindex_to_p2wpkhindex = ComputedVec::forced_import_or_init_from_1(
+        let p2wpkhaddressindex_to_p2wpkhaddressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2wpkhindex",
+            "p2wpkhaddressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2wpkhindex_to_p2wpkhbytes.boxed_clone(),
+            indexer.vecs.p2wpkhaddressindex_to_p2wpkhbytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2wshindex_to_p2wshindex = ComputedVec::forced_import_or_init_from_1(
+        let p2wshaddressindex_to_p2wshaddressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2wshindex",
+            "p2wshaddressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2wshindex_to_p2wshbytes.boxed_clone(),
+            indexer.vecs.p2wshaddressindex_to_p2wshbytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2aindex_to_p2aindex = ComputedVec::forced_import_or_init_from_1(
+        let p2aaddressindex_to_p2aaddressindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2aindex",
+            "p2aaddressindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2aindex_to_p2abytes.boxed_clone(),
+            indexer.vecs.p2aaddressindex_to_p2abytes.boxed_clone(),
            |index, _| Some(index),
        )?;
-        let p2msindex_to_p2msindex = ComputedVec::forced_import_or_init_from_1(
+        let p2msoutputindex_to_p2msoutputindex = ComputedVec::forced_import_or_init_from_1(
            computation,
            path,
-            "p2msindex",
+            "p2msoutputindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().p2msindex_to_txindex.boxed_clone(),
+            indexer.vecs.p2msoutputindex_to_txindex.boxed_clone(),
            |index, _| Some(index),
        )?;
        let emptyoutputindex_to_emptyoutputindex = ComputedVec::forced_import_or_init_from_1(
@@ -259,7 +264,7 @@ impl Vecs {
            "emptyoutputindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().emptyoutputindex_to_txindex.boxed_clone(),
+            indexer.vecs.emptyoutputindex_to_txindex.boxed_clone(),
            |index, _| Some(index),
        )?;
        let unknownoutputindex_to_unknownoutputindex = ComputedVec::forced_import_or_init_from_1(
@@ -268,7 +273,7 @@ impl Vecs {
            "unknownoutputindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().unknownoutputindex_to_txindex.boxed_clone(),
+            indexer.vecs.unknownoutputindex_to_txindex.boxed_clone(),
            |index, _| Some(index),
        )?;
        let opreturnindex_to_opreturnindex = ComputedVec::forced_import_or_init_from_1(
@@ -277,7 +282,7 @@ impl Vecs {
            "opreturnindex",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().opreturnindex_to_txindex.boxed_clone(),
+            indexer.vecs.opreturnindex_to_txindex.boxed_clone(),
            |index, _| Some(index),
        )?;

@@ -286,15 +291,15 @@ impl Vecs {
            inputindex_to_inputindex,
            opreturnindex_to_opreturnindex,
            outputindex_to_outputindex,
-            p2aindex_to_p2aindex,
-            p2msindex_to_p2msindex,
-            p2pk33index_to_p2pk33index,
-            p2pk65index_to_p2pk65index,
-            p2pkhindex_to_p2pkhindex,
-            p2shindex_to_p2shindex,
-            p2trindex_to_p2trindex,
-            p2wpkhindex_to_p2wpkhindex,
-            p2wshindex_to_p2wshindex,
+            p2aaddressindex_to_p2aaddressindex,
+            p2msoutputindex_to_p2msoutputindex,
+            p2pk33addressindex_to_p2pk33addressindex,
+            p2pk65addressindex_to_p2pk65addressindex,
+            p2pkhaddressindex_to_p2pkhaddressindex,
+            p2shaddressindex_to_p2shaddressindex,
+            p2traddressindex_to_p2traddressindex,
+            p2wpkhaddressindex_to_p2wpkhaddressindex,
+            p2wshaddressindex_to_p2wshaddressindex,
            txindex_to_input_count,
            txindex_to_output_count,
            txindex_to_txindex,
@@ -543,108 +548,115 @@ impl Vecs {
        starting_indexes: brk_indexer::Indexes,
        exit: &Exit,
    ) -> color_eyre::Result<Indexes> {
-        let indexer_vecs = indexer.vecs();
-
        // ---
        // OutputIndex
        // ---

        self.outputindex_to_outputindex.compute_if_necessary(
            starting_indexes.outputindex,
-            &indexer_vecs.outputindex_to_value,
+            &indexer.vecs.outputindex_to_value,
            exit,
        )?;

        self.txindex_to_output_count.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer_vecs.txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.txindex_to_input_count.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer_vecs.txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.outputindex_to_txindex.compute_inverse_less_to_more(
            starting_indexes.txindex,
-            &indexer_vecs.txindex_to_first_outputindex,
+            &indexer.vecs.txindex_to_first_outputindex,
            &self.txindex_to_output_count,
            exit,
        )?;

-        self.p2pk33index_to_p2pk33index.compute_if_necessary(
-            starting_indexes.p2pk33index,
-            &indexer_vecs.p2pk33index_to_p2pk33bytes,
-            exit,
-        )?;
+        self.p2pk33addressindex_to_p2pk33addressindex
+            .compute_if_necessary(
+                starting_indexes.p2pk33addressindex,
+                &indexer.vecs.p2pk33addressindex_to_p2pk33bytes,
+                exit,
+            )?;

-        self.p2pk65index_to_p2pk65index.compute_if_necessary(
-            starting_indexes.p2pk65index,
-            &indexer_vecs.p2pk65index_to_p2pk65bytes,
-            exit,
-        )?;
+        self.p2pk65addressindex_to_p2pk65addressindex
+            .compute_if_necessary(
+                starting_indexes.p2pk65addressindex,
+                &indexer.vecs.p2pk65addressindex_to_p2pk65bytes,
+                exit,
+            )?;

-        self.p2pkhindex_to_p2pkhindex.compute_if_necessary(
-            starting_indexes.p2pkhindex,
-            &indexer_vecs.p2pkhindex_to_p2pkhbytes,
-            exit,
-        )?;
+        self.p2pkhaddressindex_to_p2pkhaddressindex
+            .compute_if_necessary(
+                starting_indexes.p2pkhaddressindex,
+                &indexer.vecs.p2pkhaddressindex_to_p2pkhbytes,
+                exit,
+            )?;

-        self.p2shindex_to_p2shindex.compute_if_necessary(
-            starting_indexes.p2shindex,
-            &indexer_vecs.p2shindex_to_p2shbytes,
-            exit,
-        )?;
+        self.p2shaddressindex_to_p2shaddressindex
+            .compute_if_necessary(
+                starting_indexes.p2shaddressindex,
+                &indexer.vecs.p2shaddressindex_to_p2shbytes,
+                exit,
+            )?;

-        self.p2trindex_to_p2trindex.compute_if_necessary(
-            starting_indexes.p2trindex,
-            &indexer_vecs.p2trindex_to_p2trbytes,
-            exit,
-        )?;
+        self.p2traddressindex_to_p2traddressindex
+            .compute_if_necessary(
+                starting_indexes.p2traddressindex,
+                &indexer.vecs.p2traddressindex_to_p2trbytes,
+                exit,
+            )?;

-        self.p2wpkhindex_to_p2wpkhindex.compute_if_necessary(
-            starting_indexes.p2wpkhindex,
-            &indexer_vecs.p2wpkhindex_to_p2wpkhbytes,
-            exit,
-        )?;
+        self.p2wpkhaddressindex_to_p2wpkhaddressindex
+            .compute_if_necessary(
+                starting_indexes.p2wpkhaddressindex,
+                &indexer.vecs.p2wpkhaddressindex_to_p2wpkhbytes,
+                exit,
+            )?;

-        self.p2wshindex_to_p2wshindex.compute_if_necessary(
-            starting_indexes.p2wshindex,
-            &indexer_vecs.p2wshindex_to_p2wshbytes,
-            exit,
-        )?;
+        self.p2wshaddressindex_to_p2wshaddressindex
+            .compute_if_necessary(
+                starting_indexes.p2wshaddressindex,
+                &indexer.vecs.p2wshaddressindex_to_p2wshbytes,
+                exit,
+            )?;

        self.emptyoutputindex_to_emptyoutputindex
            .compute_if_necessary(
                starting_indexes.emptyoutputindex,
-                &indexer_vecs.emptyoutputindex_to_txindex,
+                &indexer.vecs.emptyoutputindex_to_txindex,
                exit,
            )?;

-        self.p2msindex_to_p2msindex.compute_if_necessary(
-            starting_indexes.p2msindex,
-            &indexer_vecs.p2msindex_to_txindex,
-            exit,
-        )?;
+        self.p2msoutputindex_to_p2msoutputindex
+            .compute_if_necessary(
+                starting_indexes.p2msoutputindex,
+                &indexer.vecs.p2msoutputindex_to_txindex,
+                exit,
+            )?;

        self.opreturnindex_to_opreturnindex.compute_if_necessary(
            starting_indexes.opreturnindex,
-            &indexer_vecs.opreturnindex_to_txindex,
+            &indexer.vecs.opreturnindex_to_txindex,
            exit,
        )?;

-        self.p2aindex_to_p2aindex.compute_if_necessary(
-            starting_indexes.p2aindex,
-            &indexer_vecs.p2aindex_to_p2abytes,
-            exit,
-        )?;
+        self.p2aaddressindex_to_p2aaddressindex
+            .compute_if_necessary(
+                starting_indexes.p2aaddressindex,
+                &indexer.vecs.p2aaddressindex_to_p2abytes,
+                exit,
+            )?;

        self.unknownoutputindex_to_unknownoutputindex
            .compute_if_necessary(
                starting_indexes.unknownoutputindex,
-                &indexer_vecs.unknownoutputindex_to_txindex,
+                &indexer.vecs.unknownoutputindex_to_txindex,
                exit,
            )?;

@@ -654,7 +666,7 @@ impl Vecs {

        self.inputindex_to_inputindex.compute_if_necessary(
            starting_indexes.inputindex,
-            &indexer_vecs.inputindex_to_outputindex,
+            &indexer.vecs.inputindex_to_outputindex,
            exit,
        )?;

@@ -664,20 +676,20 @@ impl Vecs {

        self.txindex_to_txindex.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer_vecs.txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.height_to_txindex_count.compute_count_from_indexes(
            starting_indexes.height,
-            &indexer_vecs.height_to_first_txindex,
-            &indexer_vecs.txindex_to_txid,
+            &indexer.vecs.height_to_first_txindex,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.txindex_to_height.compute_inverse_less_to_more(
            starting_indexes.height,
-            &indexer_vecs.height_to_first_txindex,
+            &indexer.vecs.height_to_first_txindex,
            &self.height_to_txindex_count,
            exit,
        )?;
@@ -688,13 +700,13 @@ impl Vecs {

        self.height_to_height.compute_from_index(
            starting_indexes.height,
-            &indexer_vecs.height_to_weight,
+            &indexer.vecs.height_to_weight,
            exit,
        )?;

        self.height_to_date.compute_transform(
            starting_indexes.height,
-            &indexer_vecs.height_to_timestamp,
+            &indexer.vecs.height_to_timestamp,
            |(h, t, ..)| (h, Date::from(t)),
            exit,
        )?;
@@ -702,7 +714,7 @@ impl Vecs {
        let mut prev_timestamp_fixed = None;
        self.height_to_timestamp_fixed.compute_transform(
            starting_indexes.height,
-            &indexer_vecs.height_to_timestamp,
+            &indexer.vecs.height_to_timestamp,
            |(h, timestamp, height_to_timestamp_fixed_iter)| {
                if prev_timestamp_fixed.is_none() {
                    if let Some(prev_h) = h.decremented() {
@@ -779,7 +791,7 @@ impl Vecs {
        self.dateindex_to_height_count.compute_count_from_indexes(
            starting_dateindex,
            &self.dateindex_to_first_height,
-            &indexer_vecs.height_to_weight,
+            &indexer.vecs.height_to_weight,
            exit,
        )?;

@@ -829,7 +841,7 @@ impl Vecs {

        self.height_to_difficultyepoch.compute_from_index(
            starting_indexes.height,
-            &indexer_vecs.height_to_weight,
+            &indexer.vecs.height_to_weight,
            exit,
        )?;

@@ -979,7 +991,7 @@ impl Vecs {

        self.height_to_halvingepoch.compute_from_index(
            starting_indexes.height,
-            &indexer_vecs.height_to_weight,
+            &indexer.vecs.height_to_weight,
            exit,
        )?;

@@ -1079,15 +1091,15 @@ impl Vecs {
            &self.monthindex_to_yearindex,
            &self.opreturnindex_to_opreturnindex,
            &self.outputindex_to_outputindex,
-            &self.p2aindex_to_p2aindex,
-            &self.p2msindex_to_p2msindex,
-            &self.p2pk33index_to_p2pk33index,
-            &self.p2pk65index_to_p2pk65index,
-            &self.p2pkhindex_to_p2pkhindex,
-            &self.p2shindex_to_p2shindex,
-            &self.p2trindex_to_p2trindex,
-            &self.p2wpkhindex_to_p2wpkhindex,
-            &self.p2wshindex_to_p2wshindex,
+            &self.p2aaddressindex_to_p2aaddressindex,
+            &self.p2msoutputindex_to_p2msoutputindex,
+            &self.p2pk33addressindex_to_p2pk33addressindex,
+            &self.p2pk65addressindex_to_p2pk65addressindex,
+            &self.p2pkhaddressindex_to_p2pkhaddressindex,
+            &self.p2shaddressindex_to_p2shaddressindex,
+            &self.p2traddressindex_to_p2traddressindex,
+            &self.p2wpkhaddressindex_to_p2wpkhaddressindex,
+            &self.p2wshaddressindex_to_p2wshaddressindex,
            &self.quarterindex_to_first_monthindex,
            &self.quarterindex_to_monthindex_count,
            &self.quarterindex_to_quarterindex,
@@ -1,4 +1,4 @@
-use std::{fs, path::Path, thread};
+use std::{path::Path, thread};

 use brk_core::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredUsize, Version};
 use brk_exit::Exit;
@@ -36,11 +36,15 @@ pub struct Vecs {
    pub indexes_to_55d_sma: ComputedRatioVecsFromDateIndex,
    pub indexes_to_89d_sma: ComputedRatioVecsFromDateIndex,
    pub indexes_to_144d_sma: ComputedRatioVecsFromDateIndex,
+    pub indexes_to_200d_sma: ComputedRatioVecsFromDateIndex,
    pub indexes_to_1y_sma: ComputedRatioVecsFromDateIndex,
    pub indexes_to_2y_sma: ComputedRatioVecsFromDateIndex,
    pub indexes_to_200w_sma: ComputedRatioVecsFromDateIndex,
    pub indexes_to_4y_sma: ComputedRatioVecsFromDateIndex,

+    pub indexes_to_200d_sma_x2_4: ComputedVecsFromDateIndex<Dollars>,
+    pub indexes_to_200d_sma_x0_8: ComputedVecsFromDateIndex<Dollars>,
+
    pub price_1d_ago: ComputedVecsFromDateIndex<Dollars>,
    pub price_1w_ago: ComputedVecsFromDateIndex<Dollars>,
    pub price_1m_ago: ComputedVecsFromDateIndex<Dollars>,
@@ -164,8 +168,6 @@ impl Vecs {
        _computation: Computation,
        format: Format,
    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
        Ok(Self {
            height_to_marketcap: EagerVec::forced_import(
                path,
@@ -240,7 +242,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_8d_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -248,7 +249,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_13d_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -256,7 +256,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_21d_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -264,7 +263,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_1m_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -272,7 +270,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_34d_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -280,7 +277,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_55d_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -288,7 +284,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_89d_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -296,7 +291,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_144d_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -304,7 +298,13 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_200d_sma: ComputedRatioVecsFromDateIndex::forced_import(
+                path,
+                "200d_sma",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
            )?,
            indexes_to_1y_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -312,7 +312,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_2y_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -320,7 +319,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_200w_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -328,7 +326,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,
            indexes_to_4y_sma: ComputedRatioVecsFromDateIndex::forced_import(
                path,
@@ -336,7 +333,6 @@ impl Vecs {
                true,
                version + VERSION + Version::ZERO,
                format,
-                StorableVecGeneatorOptions::default().add_last(),
            )?,

            _1d_returns: ComputedVecsFromDateIndex::forced_import(
@@ -1215,6 +1211,23 @@ impl Vecs {
                format,
                StorableVecGeneatorOptions::default().add_last(),
            )?,
+
+            indexes_to_200d_sma_x2_4: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "200d_sma_x2_4",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_200d_sma_x0_8: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "200d_sma_x0_8",
+                true,
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
        })
    }

@@ -1771,6 +1784,7 @@ impl Vecs {
                (&mut self.indexes_to_55d_sma, 55),
                (&mut self.indexes_to_89d_sma, 89),
                (&mut self.indexes_to_144d_sma, 144),
+                (&mut self.indexes_to_200d_sma, 200),
                (&mut self.indexes_to_1y_sma, 365),
                (&mut self.indexes_to_2y_sma, 2 * 365),
                (&mut self.indexes_to_200w_sma, 200 * 7),
@@ -1797,7 +1811,51 @@ impl Vecs {
                });
            });
            Ok(())
-        })
+        })?;
+
+        self.indexes_to_200d_sma_x0_8.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    self.indexes_to_200d_sma
+                        .price
+                        .as_ref()
+                        .unwrap()
+                        .dateindex
+                        .as_ref()
+                        .unwrap(),
+                    |(i, v, ..)| (i, v * 0.8),
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_200d_sma_x2_4.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    self.indexes_to_200d_sma
+                        .price
+                        .as_ref()
+                        .unwrap()
+                        .dateindex
+                        .as_ref()
+                        .unwrap(),
+                    |(i, v, ..)| (i, v * 2.4),
+                    exit,
+                )
+            },
+        )?;
+
+        Ok(())
    }

    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
@@ -1817,10 +1875,13 @@ impl Vecs {
            self.indexes_to_55d_sma.vecs(),
            self.indexes_to_89d_sma.vecs(),
            self.indexes_to_144d_sma.vecs(),
+            self.indexes_to_200d_sma.vecs(),
            self.indexes_to_1y_sma.vecs(),
            self.indexes_to_2y_sma.vecs(),
            self.indexes_to_200w_sma.vecs(),
            self.indexes_to_4y_sma.vecs(),
+            self.indexes_to_200d_sma_x0_8.vecs(),
+            self.indexes_to_200d_sma_x2_4.vecs(),
            self.price_1d_ago.vecs(),
            self.price_1w_ago.vecs(),
            self.price_1m_ago.vecs(),
@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::{DifficultyEpoch, HalvingEpoch, StoredF64, Version};
 use brk_exit::Exit;
@@ -27,8 +27,6 @@ impl Vecs {
        _computation: Computation,
        format: Format,
    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
        Ok(Self {
            indexes_to_difficulty: ComputedVecsFromHeight::forced_import(
                path,
@@ -116,7 +114,7 @@ impl Vecs {
            indexes,
            starting_indexes,
            exit,
-            Some(&indexer.vecs().height_to_difficulty),
+            Some(&indexer.vecs.height_to_difficulty),
        )?;

        Ok(())
@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::Version;
 use brk_exit::Exit;
@@ -7,6 +7,7 @@ use brk_indexer::Indexer;
 use brk_vec::{AnyCollectableVec, Computation, Format};

 pub mod blocks;
+pub mod cointime;
 pub mod constants;
 pub mod fetched;
 pub mod grouped;
@@ -19,6 +20,8 @@ pub mod transactions;
 pub use indexes::Indexes;
 use log::info;

+use crate::stores::Stores;
+
 const VERSION: Version = Version::ONE;

 #[derive(Clone)]
@@ -31,6 +34,7 @@ pub struct Vecs {
    pub transactions: transactions::Vecs,
    pub stateful: stateful::Vecs,
    pub fetched: Option<fetched::Vecs>,
+    pub cointime: cointime::Vecs,
 }

 impl Vecs {
@@ -42,8 +46,6 @@ impl Vecs {
        computation: Computation,
        format: Format,
    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
        let indexes = indexes::Vecs::forced_import(
            path,
            version + VERSION + Version::ZERO,
@@ -103,6 +105,13 @@ impl Vecs {
                format,
                fetched.as_ref(),
            )?,
+            cointime: cointime::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+                fetched.as_ref(),
+            )?,
            indexes,
            fetched,
        })
@@ -114,8 +123,10 @@ impl Vecs {
        starting_indexes: brk_indexer::Indexes,
        fetcher: Option<&mut Fetcher>,
        exit: &Exit,
+        stores: &mut Stores,
    ) -> color_eyre::Result<()> {
-        let starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
+        info!("Computing indexes...");
+        let mut starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;

        info!("Computing constants...");
        self.constants
@@ -168,7 +179,18 @@ impl Vecs {
            &self.transactions,
            self.fetched.as_ref(),
            &self.market,
-            starting_indexes,
+            &mut starting_indexes,
+            exit,
+            stores,
+        )?;
+
+        self.cointime.compute(
+            indexer,
+            &self.indexes,
+            &starting_indexes,
+            self.fetched.as_ref(),
+            &self.transactions,
+            &self.stateful,
            exit,
        )?;

@@ -184,6 +206,7 @@ impl Vecs {
            self.market.vecs(),
            self.transactions.vecs(),
            self.stateful.vecs(),
+            self.cointime.vecs(),
            self.fetched.as_ref().map_or(vec![], |v| v.vecs()),
        ]
        .into_iter()
@@ -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
+    }
+}
@@ -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))
+    }
+}
@@ -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()
+        }
+    }
+}
@@ -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(())
+    }
+}
@@ -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<_>>()
+    }
+}
@@ -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(),
+        })
+    }
+}
@@ -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);
+        }
+    }
+}
@@ -1,33 +1,31 @@
-use core::panic;
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::{
    Bitcoin, DateIndex, Dollars, Height, Result, Sats, StoredF32, StoredF64, StoredUsize, Version,
 };
 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>,
@@ -57,7 +55,7 @@ pub struct Vecs {
    pub indexes_to_coinblocks_destroyed: ComputedVecsFromHeight<StoredF64>,
    pub indexes_to_coindays_destroyed: ComputedVecsFromHeight<StoredF64>,
    pub dateindex_to_adjusted_spent_output_profit_ratio: Option<EagerVec<DateIndex, StoredF32>>,
-    pub dateindex_to_realized_cap_30d_change: Option<EagerVec<DateIndex, Dollars>>,
+    pub indexes_to_realized_cap_30d_change: Option<ComputedVecsFromDateIndex<Dollars>>,
    pub dateindex_to_sell_side_risk_ratio: Option<EagerVec<DateIndex, StoredF32>>,
    pub dateindex_to_spent_output_profit_ratio: Option<EagerVec<DateIndex, StoredF32>>,
    pub indexes_to_adjusted_value_created: Option<ComputedVecsFromHeight<Dollars>>,
@@ -89,6 +87,10 @@ pub struct Vecs {
        Option<EagerVec<Height, StoredF32>>,
    pub indexes_to_net_unrealized_profit_and_loss_relative_to_market_cap:
        Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub indexes_to_realized_profit_relative_to_realized_cap:
+        Option<ComputedVecsFromHeight<StoredF32>>,
+    pub indexes_to_realized_loss_relative_to_realized_cap:
+        Option<ComputedVecsFromHeight<StoredF32>>,
    pub indexes_to_net_realized_profit_and_loss_relative_to_realized_cap:
        Option<ComputedVecsFromHeight<StoredF32>>,
    pub height_to_supply_even_value: Option<ComputedHeightValueVecs>,
@@ -117,6 +119,12 @@ pub struct Vecs {
        Option<ComputedVecsFromDateIndex<StoredF64>>,
    pub indexes_to_supply_in_profit_relative_to_circulating_supply:
        Option<ComputedVecsFromDateIndex<StoredF64>>,
+    pub indexes_to_net_realized_profit_and_loss_cumulative_30d_change:
+        Option<ComputedVecsFromDateIndex<Dollars>>,
+    pub indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap:
+        Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap:
+        Option<ComputedVecsFromDateIndex<StoredF32>>,
 }

 impl Vecs {
@@ -128,26 +136,15 @@ 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();

-        fs::create_dir_all(path)?;
-
        // let prefix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{s}_{name}"));

        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(
@@ -412,7 +409,6 @@ impl Vecs {
                    false,
                    version + VERSION + Version::ZERO,
                    format,
-                    StorableVecGeneatorOptions::default().add_last(),
                )
                .unwrap()
            }),
@@ -432,7 +428,9 @@ impl Vecs {
                    false,
                    version + VERSION + Version::ZERO,
                    format,
-                    StorableVecGeneatorOptions::default().add_sum(),
+                    StorableVecGeneatorOptions::default()
+                        .add_sum()
+                        .add_cumulative(),
                )
                .unwrap()
            }),
@@ -452,7 +450,9 @@ impl Vecs {
                    false,
                    version + VERSION + Version::ZERO,
                    format,
-                    StorableVecGeneatorOptions::default().add_sum(),
+                    StorableVecGeneatorOptions::default()
+                        .add_sum()
+                        .add_cumulative(),
                )
                .unwrap()
            }),
@@ -463,7 +463,7 @@ impl Vecs {
                    true,
                    version + VERSION + Version::ONE,
                    format,
-                    StorableVecGeneatorOptions::default().add_sum(),
+                    StorableVecGeneatorOptions::default().add_sum().add_cumulative(),
                )
                .unwrap()
            }),
@@ -558,12 +558,14 @@ impl Vecs {
                )
                .unwrap()
            }),
-            dateindex_to_realized_cap_30d_change: compute_dollars.then(|| {
-                EagerVec::forced_import(
+            indexes_to_realized_cap_30d_change: compute_dollars.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
                    path,
                    &suffix("realized_cap_30d_change"),
+                    true,
                    version + VERSION + Version::ZERO,
                    format,
+                    StorableVecGeneatorOptions::default().add_last(),
                )
                .unwrap()
            }),
@@ -574,7 +576,9 @@ impl Vecs {
                    true,
                    version + VERSION + Version::ZERO,
                    format,
-                    StorableVecGeneatorOptions::default().add_sum(),
+                    StorableVecGeneatorOptions::default()
+                        .add_sum()
+                        .add_cumulative(),
                )
                .unwrap()
            }),
@@ -686,15 +690,37 @@ impl Vecs {
                    .unwrap()
                },
            ),
+            indexes_to_realized_profit_relative_to_realized_cap: compute_dollars.then(|| {
+                ComputedVecsFromHeight::forced_import(
+                    path,
+                    &suffix("realized_profit_relative_to_realized_cap"),
+                    true,
+                    version + VERSION + Version::ZERO,
+                    format,
+                    StorableVecGeneatorOptions::default().add_sum(),
+                )
+                .unwrap()
+            }),
+            indexes_to_realized_loss_relative_to_realized_cap: compute_dollars.then(|| {
+                ComputedVecsFromHeight::forced_import(
+                    path,
+                    &suffix("realized_loss_relative_to_realized_cap"),
+                    true,
+                    version + VERSION + Version::ZERO,
+                    format,
+                    StorableVecGeneatorOptions::default().add_sum(),
+                )
+                .unwrap()
+            }),
            indexes_to_net_realized_profit_and_loss_relative_to_realized_cap: compute_dollars.then(
                || {
                    ComputedVecsFromHeight::forced_import(
                        path,
                        &suffix("net_realized_profit_and_loss_relative_to_realized_cap"),
                        true,
-                        version + VERSION + Version::ZERO,
+                        version + VERSION + Version::ONE,
                        format,
-                        StorableVecGeneatorOptions::default().add_last(),
+                        StorableVecGeneatorOptions::default().add_sum(),
                    )
                    .unwrap()
                },
@@ -893,7 +919,7 @@ impl Vecs {
                true,
                version + VERSION + Version::TWO,
                format,
-                StorableVecGeneatorOptions::default().add_sum(),
+                StorableVecGeneatorOptions::default().add_sum().add_cumulative(),
            )?,
            indexes_to_coindays_destroyed: ComputedVecsFromHeight::forced_import(
                path,
@@ -901,17 +927,46 @@ impl Vecs {
                true,
                version + VERSION + Version::TWO,
                format,
-                StorableVecGeneatorOptions::default().add_sum(),
+                StorableVecGeneatorOptions::default().add_sum().add_cumulative(),
            )?,
+            indexes_to_net_realized_profit_and_loss_cumulative_30d_change: compute_dollars.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    path,
+                    &suffix("net_realized_profit_and_loss_cumulative_30d_change"),
+                    true,
+                    version + VERSION + Version::new(3),
+                    format,
+                    StorableVecGeneatorOptions::default().add_last()
+                )
+                .unwrap()
+            }),
+            indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap: compute_dollars.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    path,
+                    &suffix("net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap"),
+                    true,
+                    version + VERSION + Version::new(3),
+                    format,
+                    StorableVecGeneatorOptions::default().add_last()
+                )
+                .unwrap()
+            }),
+            indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap: compute_dollars.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    path,
+                    &suffix("net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap"),
+                    true,
+                    version + VERSION + Version::new(3),
+                    format,
+                    StorableVecGeneatorOptions::default().add_last()
+                )
+                .unwrap()
+            }),
        })
    }

    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
@@ -965,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);
            }
@@ -1216,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!();
            });

@@ -1285,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
@@ -1292,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,
@@ -1304,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()
@@ -1366,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)?;
@@ -1448,7 +1498,7 @@ impl Vecs {
                .safe_flush(exit)?;
        }

-        self.state.commit(height)?;
+        state.commit(height)?;

        Ok(())
    }
@@ -1877,6 +1927,7 @@ impl 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<()> {
        if let Some(v) = self
@@ -2021,18 +2072,26 @@ impl Vecs {
                    Some(self.height_to_adjusted_value_destroyed.as_ref().unwrap()),
                )?;

-            self.dateindex_to_realized_cap_30d_change
+            self.indexes_to_realized_cap_30d_change
                .as_mut()
                .unwrap()
-                .compute_change(
-                    starting_indexes.dateindex,
-                    self.indexes_to_realized_cap
-                        .as_ref()
-                        .unwrap()
-                        .dateindex
-                        .unwrap_last(),
-                    30,
+                .compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
                    exit,
+                    |vec, _, _, starting_indexes, exit| {
+                        vec.compute_change(
+                            starting_indexes.dateindex,
+                            self.indexes_to_realized_cap
+                                .as_ref()
+                                .unwrap()
+                                .dateindex
+                                .unwrap_last(),
+                            30,
+                            exit,
+                        )
+                    },
                )?;

            self.indexes_to_net_realized_profit_and_loss
@@ -2280,6 +2339,42 @@ impl Vecs {
                    },
                )?;

+            self.indexes_to_realized_profit_relative_to_realized_cap
+                .as_mut()
+                .unwrap()
+                .compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |vec, _, _, starting_indexes, exit| {
+                        vec.compute_percentage(
+                            starting_indexes.height,
+                            self.height_to_realized_profit.as_ref().unwrap(),
+                            *height_to_realized_cap.as_ref().unwrap(),
+                            exit,
+                        )
+                    },
+                )?;
+
+            self.indexes_to_realized_loss_relative_to_realized_cap
+                .as_mut()
+                .unwrap()
+                .compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |vec, _, _, starting_indexes, exit| {
+                        vec.compute_percentage(
+                            starting_indexes.height,
+                            self.height_to_realized_loss.as_ref().unwrap(),
+                            *height_to_realized_cap.as_ref().unwrap(),
+                            exit,
+                        )
+                    },
+                )?;
+
            self.indexes_to_net_realized_profit_and_loss_relative_to_realized_cap
                .as_mut()
                .unwrap()
@@ -2435,6 +2530,64 @@ impl Vecs {
                    },
                )?;

+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change
+                .as_mut()
+                .unwrap()
+                .compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |v, _, _, starting_indexes, exit| {
+                        v.compute_change(
+                            starting_indexes.dateindex,
+                            self.indexes_to_net_realized_profit_and_loss
+                                .as_ref()
+                                .unwrap()
+                                .dateindex
+                                .unwrap_cumulative(),
+                            30,
+                            exit,
+                        )
+                    },
+                )?;
+
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change_relative_to_realized_cap.
+                as_mut()
+                .unwrap()
+                .compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |v, _, _, starting_indexes, exit| {
+                        v.compute_percentage(
+                            starting_indexes.dateindex,
+                            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_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap.
+                as_mut()
+                .unwrap()
+                .compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |v, _, _, starting_indexes, exit| {
+                        v.compute_percentage(
+                            starting_indexes.dateindex,
+                            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,
+                        )
+                    },
+                )?;
+
            if let Some(height_to_supply_even_relative_to_circulating_supply) = self
                .height_to_supply_even_relative_to_circulating_supply
                .as_mut()
@@ -2618,9 +2771,9 @@ impl Vecs {
            self.indexes_to_adjusted_value_destroyed
                .as_ref()
                .map_or(vec![], |v| v.vecs()),
-            self.dateindex_to_realized_cap_30d_change
+            self.indexes_to_realized_cap_30d_change
                .as_ref()
-                .map_or(vec![], |v| vec![v]),
+                .map_or(vec![], |v| v.vecs()),
            self.indexes_to_net_realized_profit_and_loss
                .as_ref()
                .map_or(vec![], |v| v.vecs()),
@@ -2703,6 +2856,12 @@ impl Vecs {
            self.indexes_to_net_unrealized_profit_and_loss_relative_to_market_cap
                .as_ref()
                .map_or(vec![], |v| v.vecs()),
+            self.indexes_to_realized_profit_relative_to_realized_cap
+                .as_ref()
+                .map_or(vec![], |v| v.vecs()),
+            self.indexes_to_realized_loss_relative_to_realized_cap
+                .as_ref()
+                .map_or(vec![], |v| v.vecs()),
            self.indexes_to_net_realized_profit_and_loss_relative_to_realized_cap
                .as_ref()
                .map_or(vec![], |v| v.vecs()),
@@ -2756,6 +2915,12 @@ impl Vecs {
                .map_or(vec![], |v| v.vecs()),
            self.indexes_to_coinblocks_destroyed.vecs(),
            self.indexes_to_coindays_destroyed.vecs(),
+            self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change.as_ref()
+            .map_or(vec![], |v| v.vecs()),
+            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_net_realized_profit_and_loss_cumulative_30d_change_relative_to_market_cap.as_ref()
+            .map_or(vec![], |v| v.vecs()),
        ]
        .into_iter()
        .flatten()
@@ -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_overlaping_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_overlaping_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)
-        })
-    }
-}
@@ -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<()>;
+}
@@ -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
+    }
+}
@@ -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())
+            }
+        }
+    }
+}
@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::{
    CheckedSub, Feerate, HalvingEpoch, Height, InputIndex, OutputIndex, Sats, StoredU32,
@@ -98,27 +98,25 @@ impl Vecs {
    ) -> color_eyre::Result<Self> {
        let compute_dollars = fetched.is_some();

-        fs::create_dir_all(path)?;
-
        let inputindex_to_value = ComputedVec::forced_import_or_init_from_2(
            computation,
            path,
            "value",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().inputindex_to_outputindex.boxed_clone(),
-            indexer.vecs().outputindex_to_value.boxed_clone(),
+            indexer.vecs.inputindex_to_outputindex.boxed_clone(),
+            indexer.vecs.outputindex_to_value.boxed_clone(),
            |index: InputIndex, inputindex_to_outputindex_iter, outputindex_to_value_iter| {
                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!()
@@ -133,19 +131,19 @@ impl Vecs {
            "weight",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().txindex_to_base_size.boxed_clone(),
-            indexer.vecs().txindex_to_total_size.boxed_clone(),
+            indexer.vecs.txindex_to_base_size.boxed_clone(),
+            indexer.vecs.txindex_to_total_size.boxed_clone(),
            |index: TxIndex, txindex_to_base_size_iter, txindex_to_total_size_iter| {
                let index = index.unwrap_to_usize();
                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);
@@ -166,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
                    )
                })
            },
@@ -179,17 +177,17 @@ impl Vecs {
            version + VERSION + Version::ZERO,
            format,
            indexes.txindex_to_height.boxed_clone(),
-            indexer.vecs().height_to_first_txindex.boxed_clone(),
+            indexer.vecs.height_to_first_txindex.boxed_clone(),
            |index: TxIndex, txindex_to_height_iter, height_to_first_txindex_iter| {
                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
                    })
@@ -202,7 +200,7 @@ impl Vecs {
            "input_value",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().txindex_to_first_inputindex.boxed_clone(),
+            indexer.vecs.txindex_to_first_inputindex.boxed_clone(),
            indexes.txindex_to_input_count.boxed_clone(),
            inputindex_to_value.boxed_clone(),
            |index: TxIndex,
@@ -213,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
@@ -226,7 +224,7 @@ impl Vecs {
                                    .next_at(inputindex)
                                    .unwrap()
                                    .1
-                                    .into_inner()
+                                    .into_owned()
                        })
                    })
            },
@@ -251,9 +249,9 @@ impl Vecs {
            "output_value",
            version + VERSION + Version::ZERO,
            format,
-            indexer.vecs().txindex_to_first_outputindex.boxed_clone(),
+            indexer.vecs.txindex_to_first_outputindex.boxed_clone(),
            indexes.txindex_to_output_count.boxed_clone(),
-            indexer.vecs().outputindex_to_value.boxed_clone(),
+            indexer.vecs.outputindex_to_value.boxed_clone(),
            |index: TxIndex,
             txindex_to_first_outputindex_iter,
             txindex_to_output_count_iter,
@@ -262,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
@@ -275,7 +273,7 @@ impl Vecs {
                                    .next_at(outputindex)
                                    .unwrap()
                                    .1
-                                    .into_inner()
+                                    .into_owned()
                        })
                    })
            },
@@ -305,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()
                    })
                })
@@ -328,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))
                    })
                })
@@ -688,8 +686,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_txindex,
-                    &indexer.vecs().txindex_to_txid,
+                    &indexer.vecs.height_to_first_txindex,
+                    &indexer.vecs.txindex_to_txid,
                    exit,
                )
            },
@@ -713,7 +711,7 @@ impl Vecs {

        let compute_indexes_to_tx_vany =
            |indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredUsize>, txversion| {
-                let mut txindex_to_txversion_iter = indexer.vecs().txindex_to_txversion.iter();
+                let mut txindex_to_txversion_iter = indexer.vecs.txindex_to_txversion.iter();
                indexes_to_tx_vany.compute_all(
                    indexer,
                    indexes,
@@ -722,8 +720,8 @@ impl Vecs {
                    |vec, indexer, _, starting_indexes, exit| {
                        vec.compute_filtered_count_from_indexes(
                            starting_indexes.height,
-                            &indexer.vecs().height_to_first_txindex,
-                            &indexer.vecs().txindex_to_txid,
+                            &indexer.vecs.height_to_first_txindex,
+                            &indexer.vecs.txindex_to_txid,
                            |txindex| {
                                let v = txindex_to_txversion_iter.unwrap_get_inner(txindex);
                                v == txversion
@@ -739,31 +737,31 @@ impl Vecs {

        self.txindex_to_is_coinbase.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer.vecs().txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.txindex_to_weight.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer.vecs().txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.txindex_to_vsize.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer.vecs().txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.inputindex_to_value.compute_if_necessary(
            starting_indexes.inputindex,
-            &indexer.vecs().inputindex_to_outputindex,
+            &indexer.vecs.inputindex_to_outputindex,
            exit,
        )?;

        self.txindex_to_output_value.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer.vecs().txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

@@ -775,9 +773,9 @@ impl Vecs {
        //     |vec, indexer, _, starting_indexes, exit| {
        //         vec.compute_sum_from_indexes(
        //             starting_indexes.txindex,
-        //             &indexer.vecs().txindex_to_first_outputindex,
+        //             &indexer.vecs.txindex_to_first_outputindex,
        //             self.indexes_to_output_count.txindex.as_ref().unwrap(),
-        //             &indexer.vecs().outputindex_to_value,
+        //             &indexer.vecs.outputindex_to_value,
        //             exit,
        //         )
        //     },
@@ -785,7 +783,7 @@ impl Vecs {

        self.txindex_to_input_value.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer.vecs().txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

@@ -797,7 +795,7 @@ impl Vecs {
        //     |vec, indexer, _, starting_indexes, exit| {
        //         vec.compute_sum_from_indexes(
        //             starting_indexes.txindex,
-        //             &indexer.vecs().txindex_to_first_inputindex,
+        //             &indexer.vecs.txindex_to_first_inputindex,
        //             self.indexes_to_input_count.txindex.as_ref().unwrap(),
        //             &self.inputindex_to_value,
        //             exit,
@@ -807,13 +805,13 @@ impl Vecs {

        self.txindex_to_fee.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer.vecs().txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

        self.txindex_to_feerate.compute_if_necessary(
            starting_indexes.txindex,
-            &indexer.vecs().txindex_to_txid,
+            &indexer.vecs.txindex_to_txid,
            exit,
        )?;

@@ -858,12 +856,12 @@ impl Vecs {
            exit,
            |vec, indexer, _, starting_indexes, exit| {
                let mut txindex_to_first_outputindex_iter =
-                    indexer.vecs().txindex_to_first_outputindex.iter();
+                    indexer.vecs.txindex_to_first_outputindex.iter();
                let mut txindex_to_output_count_iter = indexes.txindex_to_output_count.iter();
-                let mut outputindex_to_value_iter = indexer.vecs().outputindex_to_value.iter();
+                let mut outputindex_to_value_iter = indexer.vecs.outputindex_to_value.iter();
                vec.compute_transform(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_txindex,
+                    &indexer.vecs.height_to_first_txindex,
                    |(height, txindex, ..)| {
                        let first_outputindex = txindex_to_first_outputindex_iter
                            .unwrap_get_inner(txindex)
@@ -933,8 +931,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2aindex,
-                    &indexer.vecs().p2aindex_to_p2abytes,
+                    &indexer.vecs.height_to_first_p2aaddressindex,
+                    &indexer.vecs.p2aaddressindex_to_p2abytes,
                    exit,
                )
            },
@@ -948,8 +946,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2msindex,
-                    &indexer.vecs().p2msindex_to_txindex,
+                    &indexer.vecs.height_to_first_p2msoutputindex,
+                    &indexer.vecs.p2msoutputindex_to_txindex,
                    exit,
                )
            },
@@ -963,8 +961,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2pk33index,
-                    &indexer.vecs().p2pk33index_to_p2pk33bytes,
+                    &indexer.vecs.height_to_first_p2pk33addressindex,
+                    &indexer.vecs.p2pk33addressindex_to_p2pk33bytes,
                    exit,
                )
            },
@@ -978,8 +976,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2pk65index,
-                    &indexer.vecs().p2pk65index_to_p2pk65bytes,
+                    &indexer.vecs.height_to_first_p2pk65addressindex,
+                    &indexer.vecs.p2pk65addressindex_to_p2pk65bytes,
                    exit,
                )
            },
@@ -993,8 +991,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2pkhindex,
-                    &indexer.vecs().p2pkhindex_to_p2pkhbytes,
+                    &indexer.vecs.height_to_first_p2pkhaddressindex,
+                    &indexer.vecs.p2pkhaddressindex_to_p2pkhbytes,
                    exit,
                )
            },
@@ -1008,8 +1006,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2shindex,
-                    &indexer.vecs().p2shindex_to_p2shbytes,
+                    &indexer.vecs.height_to_first_p2shaddressindex,
+                    &indexer.vecs.p2shaddressindex_to_p2shbytes,
                    exit,
                )
            },
@@ -1023,8 +1021,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2trindex,
-                    &indexer.vecs().p2trindex_to_p2trbytes,
+                    &indexer.vecs.height_to_first_p2traddressindex,
+                    &indexer.vecs.p2traddressindex_to_p2trbytes,
                    exit,
                )
            },
@@ -1038,8 +1036,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2wpkhindex,
-                    &indexer.vecs().p2wpkhindex_to_p2wpkhbytes,
+                    &indexer.vecs.height_to_first_p2wpkhaddressindex,
+                    &indexer.vecs.p2wpkhaddressindex_to_p2wpkhbytes,
                    exit,
                )
            },
@@ -1053,8 +1051,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_p2wshindex,
-                    &indexer.vecs().p2wshindex_to_p2wshbytes,
+                    &indexer.vecs.height_to_first_p2wshaddressindex,
+                    &indexer.vecs.p2wshaddressindex_to_p2wshbytes,
                    exit,
                )
            },
@@ -1068,8 +1066,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_opreturnindex,
-                    &indexer.vecs().opreturnindex_to_txindex,
+                    &indexer.vecs.height_to_first_opreturnindex,
+                    &indexer.vecs.opreturnindex_to_txindex,
                    exit,
                )
            },
@@ -1083,8 +1081,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_unknownoutputindex,
-                    &indexer.vecs().unknownoutputindex_to_txindex,
+                    &indexer.vecs.height_to_first_unknownoutputindex,
+                    &indexer.vecs.unknownoutputindex_to_txindex,
                    exit,
                )
            },
@@ -1098,8 +1096,8 @@ impl Vecs {
            |v, indexer, _, starting_indexes, exit| {
                v.compute_count_from_indexes(
                    starting_indexes.height,
-                    &indexer.vecs().height_to_first_emptyoutputindex,
-                    &indexer.vecs().emptyoutputindex_to_txindex,
+                    &indexer.vecs.height_to_first_emptyoutputindex,
+                    &indexer.vecs.emptyoutputindex_to_txindex,
                    exit,
                )
            },
@@ -1,5 +0,0 @@
-mod error;
-mod value;
-
-pub use error::*;
-pub use value::*;
@@ -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,
-        }
-    }
-}
@@ -20,6 +20,7 @@ pub enum Error {

    WrongEndian,
    DifferentVersion { found: Version, expected: Version },
+    UnexpectedData,
    MmapsVecIsTooSmall,
    IndexTooHigh,
    EmptyVec,
@@ -102,12 +103,13 @@ impl fmt::Display for Error {
            Error::BincodeDecodeError(error) => Debug::fmt(&error, f),
            Error::BincodeEncodeError(error) => Debug::fmt(&error, f),
            Error::ZeroCopyError => write!(f, "ZeroCopy error"),
+            Error::UnexpectedData => write!(f, "Unexpected data"),

            Error::WrongEndian => write!(f, "Wrong endian"),
            Error::DifferentVersion { found, expected } => {
                write!(
                    f,
-                    "Different version; found: {found:?}, expected: {expected:?}"
+                    "Different version found: {found:?}, expected: {expected:?}"
                )
            }
            Error::MmapsVecIsTooSmall => write!(f, "Mmaps vec is too small"),
@@ -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),
+        }
+    }
+}
@@ -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;
+    }
+}
@@ -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,
+        ]
+    }
+}
@@ -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;
+    }
+}
@@ -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]
    }
@@ -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,
+            ),
+        }
+    }
+}
@@ -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,
+            ),
+        }
+    }
+}
@@ -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),
+        }
+    }
+}
@@ -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),
+        }
+    }
+}
@@ -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,
 {
@@ -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),
+        }
+    }
+}
@@ -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,
 {
@@ -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,
 {
@@ -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,
@@ -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,
+        }
+    }
+}
@@ -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::*;
@@ -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),
+        }
+    }
+}
@@ -1,9 +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::*;
@@ -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}")
    }
 }

@@ -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(),
+        )
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
nym21	ec64f8d048	release: v0.0.73	2025-07-09 08:36:29 +02:00
nym21	ed288a9dba	website: make panes the same size + remove saving their height	2025-07-09 00:06:38 +02:00
nym21	27da0a4102	packages: add lightweight-charts v5.0.8	2025-07-08 23:37:06 +02:00
nym21	3c01ba1a76	release: v0.0.72	2025-07-08 22:35:16 +02:00
nym21	252c8833ae	global: upgrade deps	2025-07-08 22:34:51 +02:00
nym21	f45fb6efe6	global: renames and fixes	2025-07-08 21:33:18 +02:00
nym21	8cc1f8d691	computer: add more up to and from datasets	2025-07-07 23:53:59 +02:00
nym21	bff22b5182	websites: snapshot + todo: init	2025-07-07 13:16:43 +02:00
nym21	d31d47eb32	computer: store part 10	2025-07-05 17:44:51 +02:00
nym21	5fe984c39d	indexer: rename some stores	2025-07-05 00:17:23 +02:00
nym21	7f07b0daa7	global: move addressindex_to_outputindex stores from computer to indexer	2025-07-04 17:30:43 +02:00
nym21	6d35c26b3f	computer: store part 9	2025-07-03 19:15:02 +02:00
nym21	be4e693a27	computer: store part 8	2025-07-03 18:19:36 +02:00
nym21	5810276156	computer: store part 7	2025-07-02 23:49:24 +02:00
nym21	d10ac3f87b	computer: store part 6	2025-07-02 16:02:18 +02:00
nym21	9810bc09e9	computer: store part 5	2025-07-01 20:03:00 +02:00
nym21	a0a13eb2a8	computer: store part 4	2025-07-01 13:57:48 +02:00
nym21	6e996797b8	computer: store part 3	2025-06-29 17:39:31 +02:00
nym21	663092b501	global: replace Value enum with Cow	2025-06-27 20:39:19 +02:00
nym21	8ea13544de	computer: store part 2	2025-06-27 19:38:44 +02:00
nym21	e73daa6214	computer: init store	2025-06-27 10:52:36 +02:00
nym21	cf92c60a01	mcp: readme	2025-06-26 17:41:00 +02:00
nym21	b7f51b03bc	global: snapshot	2025-06-26 16:40:29 +02:00
nym21	903e69ff77	release: v0.0.71	2025-06-25 17:59:19 +02:00
nym21	c4167ddaad	mcp: small changes	2025-06-25 10:44:24 +02:00
nym21	50bfdb0d68	release: v0.0.70	2025-06-24 23:53:30 +02:00
nym21	a6cb09ff1c	fetcher: fix brk url	2025-06-24 23:53:10 +02:00
nym21	e4c9f23476	release: v0.0.69	2025-06-24 13:23:14 +02:00
nym21	44e5415d43	vec: undo storing file in struct, can overwhelm system	2025-06-24 13:20:44 +02:00
nym21	1c653693ed	release: v0.0.68	2025-06-24 12:19:07 +02:00
nym21	39c470ad7a	core: increase max open files limit	2025-06-24 12:18:49 +02:00
nym21	1103e538a5	release: v0.0.67	2025-06-24 11:57:25 +02:00
nym21	c0cd4cba6f	global: snapshot	2025-06-24 11:56:54 +02:00
nym21	b91120e8d4	readme: update	2025-06-24 08:42:40 +00:00
nym21	005774a4c2	mcp: update readme	2025-06-24 08:41:08 +00:00
nym21	16bbfebfba	changelog: update titles	2025-06-24 08:26:01 +00:00
nym21	15505cd82d	web: fix index type imports	2025-06-24 10:23:16 +02:00
nym21	016d80e002	server: use etag for vecs instead of date modified	2025-06-24 10:11:03 +02:00
nym21	0f3c267a48	global: rename some indexes	2025-06-23 22:00:09 +02:00
nym21	589bb02411	vec: single file with header	2025-06-23 20:48:00 +02:00
nym21	c0f4ece17b	mcp: part 2	2025-06-21 20:34:14 +02:00
nym21	c3ae3cb768	server: mcp + global: refactor	2025-06-21 12:43:14 +02:00
nym21	c9e0f9d985	query: remove dup 'h' short index	2025-06-19 14:16:24 +02:00
nym21	e3431c2fa3	release: v0.0.66	2025-06-19 12:32:04 +02:00
nym21	5979b9771e	global: cointime part 1	2025-06-19 12:29:34 +02:00
nym21	aa61832fb2	web: fix options cmumulative possible vecids type	2025-06-18 10:14:09 +02:00
nym21	2ac6e982b1	computer: cumulative destroyed coinblocks and cointime	2025-06-18 10:13:33 +02:00
nym21	3204ddcf07	pr: merge #18 from StevenBlack/typos Minor refinements to the brk_cli readme	2025-06-17 23:06:32 +02:00
nym21	c87b1c133c	release: v0.0.65	2025-06-17 22:30:32 +02:00
nym21	9b275ecdae	web: fix hang when candles fetched are slightly diff than before	2025-06-17 22:30:11 +02:00
Steven Black	d6fd7de361	Minor refinements to the brk_cli readme * Fix typos * Rephrasing some descriptions * Links to run command parameters now link to the code as it is in blob `49d66a133e` specifically. * Lightly introduce some nice features of Github flavored markdown (IMPORTANT and TIP) to assess how this nuance is received by maintainers.	2025-06-17 14:07:03 -04:00
nym21	49d66a133e	release: v0.0.64	2025-06-17 18:49:17 +02:00
nym21	c559f26d0e	global: add a bunch of realized datasets + charts	2025-06-17 18:47:04 +02:00
nym21	bbe9f1bad2	global: 4y zscore + 200d sma + mayer's multiple	2025-06-17 10:01:49 +02:00
nym21	7e1fb6472d	release: v0.0.63	2025-06-16 23:46:57 +02:00
nym21	0ff8d20573	web: fix the fix for the stutter + pwa assets	2025-06-16 23:46:39 +02:00
nym21	9c1f9448dc	release: v0.0.62	2025-06-16 18:56:59 +02:00
nym21	43a6081dd6	web: fix stutter on update and save default chart settings to url params	2025-06-16 18:56:38 +02:00
nym21	985e961876	web: fix error in lockdown safari + charts: update instead of setData when possible	2025-06-16 18:20:56 +02:00
nym21	098f6de047	release: v0.0.61	2025-06-15 17:30:49 +02:00
nym21	1b0f90fd68	release: v0.0.60	2025-06-15 17:27:41 +02:00
nym21	12252f407b	computer: fix open of ohlc if fetched from different API than prev ohlc	2025-06-15 17:27:16 +02:00
nym21	3b6e3f47ab	release: v0.0.59	2025-06-15 12:40:46 +02:00
nym21	6a9ac9b025	brk: fix bundler use + bundler: remove minify html crate	2025-06-15 12:39:50 +02:00
nym21	ae6aa4088b	release: v0.0.58	2025-06-15 01:50:22 +02:00
nym21	c08f431180	bundler: deploy brk_rolldown + fix edge case	2025-06-15 01:50:01 +02:00
nym21	123c1f56e9	release: v0.0.57	2025-06-14 22:47:57 +02:00
nym21	35ac65a864	server: update cache control for bundled websites	2025-06-14 22:47:26 +02:00
nym21	e9f362cc87	bundler: init working version	2025-06-14 20:17:49 +02:00
nym21	65685c23e1	release: v0.0.56	2025-06-13 18:03:28 +02:00
nym21	2f74748cea	computer: stateful: reset when reorg detected	2025-06-13 18:03:09 +02:00
nym21	f477bd66f3	release: v0.0.55	2025-06-13 10:23:38 +02:00
nym21	d7d77ae8f0	global: multiple fixes	2025-06-13 10:22:03 +02:00
nym21	31110a740d	release: v0.0.54	2025-06-12 22:18:36 +02:00
nym21	b64d8b1d7f	release: v0.0.53	2025-06-12 22:16:33 +02:00
nym21	c46006aacc	web: filter possible index choices in charts	2025-06-12 22:09:33 +02:00
nym21	92f81b1493	web: fix css	2025-06-12 20:23:23 +02:00
nym21	70213cfc8f	websites: default: add auto price series type	2025-06-12 18:41:56 +02:00
nym21	8a82bf5c50	websites: default: add live price	2025-06-12 18:10:24 +02:00
nym21	37405384a2	vec: fixed compressed, still slow par read, cli: made raw the default	2025-06-12 16:31:54 +02:00
nym21	54ea6cc53b	indexer: only raw format + global: fixes	2025-06-12 12:33:43 +02:00
nym21	339c00d815	release: v0.0.52	2025-06-11 21:19:41 +02:00
nym21	ea6b4dcde2	websites: default: remove scrollToSelected	2025-06-11 21:19:22 +02:00
nym21	2b84623d1e	release: v0.0.51	2025-06-11 21:09:07 +02:00
nym21	c8b3afa56b	websites: default: fix sw adn co	2025-06-11 21:08:42 +02:00
nym21	1348f3c24c	release: v0.0.50	2025-06-11 18:11:22 +02:00
nym21	62208ce3e1	websites: default: fix minBarSpacing	2025-06-11 18:11:11 +02:00
nym21	813b2481de	release: v0.0.49	2025-06-11 17:51:31 +02:00
nym21	27b924ba61	cargo: set full version of crates	2025-06-11 17:51:11 +02:00
nym21	b40170b8ce	websites: default: snapshot	2025-06-11 17:45:17 +02:00
nym21	8bfa9d2734	websites: default: snapshot	2025-06-11 11:25:25 +02:00
nym21	c7cf76d4a8	websites: default: snapshot	2025-06-10 18:54:18 +02:00
nym21	dfd2969b3e	websites: default: snapshot	2025-06-09 17:58:26 +02:00
nym21	0e1866fe1d	release: v0.0.48	2025-06-09 13:53:33 +02:00
nym21	b9ae46b913	readme: update	2025-06-09 13:53:09 +02:00
nym21	06e7284055	websites: default: snapshot	2025-06-09 13:05:03 +02:00
nym21	93289e8fca	release: v0.0.47	2025-06-08 20:35:36 +02:00
nym21	130d5057d4	server: readme: add index-t-value documentation	2025-06-08 20:35:26 +02:00
nym21	be492d5084	server: add support for /api/X-to-Y + fix query cli + add meta api endpoints	2025-06-08 20:30:53 +02:00
nym21	e0bf1d736f	query: add count param	2025-06-08 18:26:59 +02:00
nym21	5a6b71cbeb	server: add ddos protection	2025-06-08 17:06:36 +02:00