release: v0.0.91

Add Docker support

.cargo/config.toml

@@ -1,2 +0,0 @@
-[build]
-rustflags = ["-C", "target-cpu=native"]

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/
+# This file was autogenerated by dist: https://axodotdev.github.io/cargo-dist
 #
 # Copyright 2022-2024, axodotdev
 # SPDX-License-Identifier: MIT or Apache-2.0
@@ -47,7 +47,7 @@ on:
 jobs:
   # Run 'dist plan' (or host) to determine what tasks we need to do
   plan:
-    runs-on: "ubuntu-latest"
+    runs-on: "ubuntu-22.04"
     outputs:
       val: ${{ steps.plan.outputs.manifest }}
       tag: ${{ !github.event.pull_request && github.ref_name || '' }}
@@ -58,12 +58,13 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
+          persist-credentials: false
           submodules: recursive
       - name: Install dist
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
         shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.28.0/cargo-dist-installer.sh | sh"
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.29.0/cargo-dist-installer.sh | sh"
       - name: Cache dist
         uses: actions/upload-artifact@v4
         with:
@@ -117,6 +118,7 @@ jobs:
           git config --global core.longpaths true
       - uses: actions/checkout@v4
         with:
+          persist-credentials: false
           submodules: recursive
       - name: Install Rust non-interactively if not already installed
         if: ${{ matrix.container }}
@@ -168,13 +170,14 @@ jobs:
     needs:
       - plan
       - build-local-artifacts
-    runs-on: "ubuntu-latest"
+    runs-on: "ubuntu-22.04"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
     steps:
       - uses: actions/checkout@v4
         with:
+          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
         uses: actions/download-artifact@v4
@@ -218,12 +221,13 @@ jobs:
     if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    runs-on: "ubuntu-latest"
+    runs-on: "ubuntu-22.04"
     outputs:
       val: ${{ steps.host.outputs.manifest }}
     steps:
       - uses: actions/checkout@v4
         with:
+          persist-credentials: false
           submodules: recursive
       - name: Install cached dist
         uses: actions/download-artifact@v4
@@ -282,10 +286,11 @@ jobs:
     # still allowing individual publish jobs to skip themselves (for prereleases).
     # "host" however must run to completion, no skipping allowed!
     if: ${{ always() && needs.host.result == 'success' }}
-    runs-on: "ubuntu-latest"
+    runs-on: "ubuntu-22.04"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
       - uses: actions/checkout@v4
         with:
+          persist-credentials: false
           submodules: recursive

.gitignore

@@ -3,35 +3,31 @@
 
 # Builds
 target
+websites/dist
+vecid-to-indexes.js
 
 # Copies
 *\ copy*
 
 # Ignored
-/_*
+_*
 
 # Editors
 .vscode
 .zed
 
-# Flamegraph
-flamegraph/
-flamegraph.svg
-
-# Benchmarks
-benches
-
-# Snapshots
-snapshots*/
-
-# Docker
-docker/kibo
-
-# Types
-paths.d.ts
-
-# Outputs
-_outputs
-
 # Logs
 .log
+
+# Environment variables/configs
+.env
+
+# Profiling
+profile.json.gz
+flamegraph.svg
+*.trace
+
+# AI
+.claude
+CLAUDE.md
+CLAUDE*.md

Cargo.toml

@@ -4,48 +4,58 @@ 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.40"
+package.version = "0.0.91"
+package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
+package.readme = "README.md"
+package.rust-version = "1.89"
 
 [profile.release]
 lto = "fat"
 codegen-units = 1
 panic = "abort"
 
+[profile.profiling]
+inherits = "release"
+debug = true
+
 [profile.dist]
 inherits = "release"
 
 [workspace.dependencies]
 axum = "0.8.4"
-bitcoin = { version = "0.32.6", features = ["serde"] }
+bitcoin = { version = "0.32.7", 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_vec = { version = "0", path = "crates/brk_vec" }
-byteview = "0.7.0"
-clap = { version = "4.5.38", features = ["string"] }
-clap_derive = "4.5.32"
-color-eyre = "0.6.4"
+brk_bundler = { version = "0.0.91", path = "crates/brk_bundler" }
+brk_cli = { version = "0.0.91", path = "crates/brk_cli" }
+brk_computer = { version = "0.0.91", path = "crates/brk_computer" }
+brk_error = { version = "0.0.91", path = "crates/brk_error" }
+brk_fetcher = { version = "0.0.91", path = "crates/brk_fetcher" }
+brk_indexer = { version = "0.0.91", path = "crates/brk_indexer" }
+brk_interface = { version = "0.0.91", path = "crates/brk_interface" }
+brk_logger = { version = "0.0.91", path = "crates/brk_logger" }
+brk_mcp = { version = "0.0.91", path = "crates/brk_mcp" }
+brk_parser = { version = "0.0.91", path = "crates/brk_parser" }
+brk_server = { version = "0.0.91", path = "crates/brk_server" }
+brk_store = { version = "0.0.91", path = "crates/brk_store" }
+brk_structs = { version = "0.0.91", path = "crates/brk_structs" }
+byteview = "=0.6.1"
 derive_deref = "1.1.1"
-fjall = "2.10.0"
-jiff = "0.2.14"
-log = { version = "0.4.27" }
-minreq = { version = "2.13.4", features = ["https", "serde_json"] }
-rayon = "1.10.0"
-serde = { version = "1.0.219" }
+fjall = "2.11.2"
+jiff = "0.2.15"
+log = "0.4.27"
+minreq = { version = "2.14.0", features = ["https", "serde_json"] }
+parking_lot = "0.12.4"
+rayon = "1.11.0"
+serde = "1.0.219"
+serde_bytes = "0.11.17"
 serde_derive = "1.0.219"
-serde_json = { version = "1.0.140", features = ["float_roundtrip"] }
-tabled = "0.19.0"
-zerocopy = { version = "0.8.25" }
-zerocopy-derive = "0.8.25"
+serde_json = { version = "1.0.143", features = ["float_roundtrip"] }
+tokio = { version = "1.47.1", features = ["rt-multi-thread"] }
+# vecdb = { path = "../seqdb/crates/vecdb", features = ["derive"]}
+vecdb = { version = "0.2.5", features = ["derive"]}
+zerocopy = "0.8.26"
+zerocopy-derive = "0.8.26"
 
 [workspace.metadata.release]
 shared-version = true
@@ -54,20 +64,9 @@ pre-release-commit-message = "release: v{{version}}"
 tag-message = "release: v{{version}}"
 
 [workspace.metadata.dist]
-cargo-dist-version = "0.28.0"
+cargo-dist-version = "0.29.0"
 ci = "github"
+allow-dirty = ["ci"]
 installers = []
-targets = [
-    "aarch64-apple-darwin",
-    "aarch64-unknown-linux-gnu",
-    "x86_64-apple-darwin",
-    "x86_64-unknown-linux-gnu",
-]
-
-[workspace.metadata.dist.github-custom-runners]
-global = "ubuntu-latest"
-aarch64-apple-darwin.runner = "macos-14"
-x86_64-unknown-linux-gnu.runner = "ubuntu-latest"
-x86_64-unknown-linux-gnu.container = { image = "quay.io/pypa/manylinux_2_28_x86_64", host = "x86_64-unknown-linux-musl" }
-aarch64-unknown-linux-gnu.runner = "ubuntu-latest"
-aarch64-unknown-linux-gnu.container = { image = "quay.io/pypa/manylinux_2_28_x86_64", host = "x86_64-unknown-linux-musl" }
+targets = ["aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"]
+rust-toolchain-version = "1.89"

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 bitcoinresearchkit, kibo.money
+Copyright (c) 2025 bitcoinresearchkit, kibo.money, satonomics
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -4,9 +4,6 @@
   <a href="https://github.com/bitcoinresearchkit/brk">
     <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/bitcoinresearchkit/brk?style=social">
   </a>
-  <a href="https://kibo.money">
-    <img alt="kibo.money" src="https://img.shields.io/badge/showcase-kib%C5%8D.money-orange">
-  </a>
   <a href="https://github.com/bitcoinresearchkit/brk/blob/main/LICENSE.md">
     <img src="https://img.shields.io/crates/l/brk" alt="License" />
   </a>
@@ -26,36 +23,27 @@
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
     <img src="https://img.shields.io/badge/nostr-purple?link=https%3A%2F%2Fprimal.net%2Fp%2Fnprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6" alt="Nostr" />
   </a>
-  <a href="https://bsky.app/profile/bitcoinresearchkit.org">
-    <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
-  </a>
-  <a href="https://x.com/brkdotorg">
-    <img src="https://img.shields.io/badge/x.com-black" alt="X" />
-  </a>
 </p>
 
-> **WARNING**
->
-> This project is still a work in progress and while it's much better in many ways than its previous version ([kibo v0.5](https://github.com/kibo-money/kibo)), it doesn't yet include all of those datasets. If you're interested in having everything right now, please use the latter until feature parity is achieved.
->
-> The explorer part (mempool.space/electrs) is also not viable just yet.
->
-> Stay tuned and please be patient, it's a lot of work !
+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.
 
-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.
-
-In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) and [electrs](https://github.com/romanz/electrs) 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: [brekit.org](https://brekit.org) // [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.
 - **[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.
@@ -64,43 +52,43 @@ The primary goal of this project is to be fully-featured and accessible for ever
 
 In contrast, existing alternatives tend to be either [very costly](https://studio.glassnode.com/pricing) or missing essential features, with the vast majority being closed-source and unverifiable, which fundamentally undermines the principles of Bitcoin.
 
-## Crates
+## Hosting as a service
 
-- [`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_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_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_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_vec`](https://crates.io/crates/brk_vec): A push-only, truncable, compressable, saveable Vec
+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
+- Configured for speed
+- Updates delivered at your convenience
+- Direct communication for feature requests and support
+- Bitcoin Core or Knots with desired version
+- Optional subdomains: `*.bitcoinresearchkit.org`, `*.brekit.org`, `*.kibo.money` and `*.satonomics.xyz`
+- Logo featured in the Readme if desired
+
+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 [kibo.money](https://kibo.money) public instance.
+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.
 
-## Hosting as a service
+## Crates
 
-*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.9% SLA
-- Configurated for speed (`raw + eager`)
-- Updates delivered at your convenience
-- Direct communication for feature requests and support
-- Bitcoin Core or Knots with desired version
-- Optional subdomains: `*.bitcoinresearchkit.org`, `*.kibo.money` and `*.satonomics.xyz`
-- Logo featured in the Readme if desired
-
-Pricing: `0.01 BTC / month` *or* `0.1 BTC / year`
+- [`brk`](https://crates.io/crates/brk): A wrapper around all other `brk-*` crates
+- [`brk_bundler`](https://crates.io/crates/brk_bundler): A thin wrapper around [`rolldown`](https://rolldown.rs/)
+- [`brk_cli`](https://crates.io/crates/brk_cli): A command line interface to run a BRK instance
+- [`brk_computer`](https://crates.io/crates/brk_computer): A Bitcoin dataset computer built on top of [`brk_indexer`](https://crates.io/crates/brk_indexer)
+- [`brk_error`](https://crates.io/crates/brk_error): Errors used throughout BRK
+- [`brk_fetcher`](https://crates.io/crates/brk_fetcher): A Bitcoin price fetcher
+- [`brk_indexer`](https://crates.io/crates/brk_indexer): A Bitcoin indexer built on top of [`brk_parser`](https://crates.io/crates/brk_parser)
+- [`brk_interface`](https://crates.io/crates/brk_interface): An interface to find and format data from BRK
+- [`brk_logger`](https://crates.io/crates/brk_logger): A thin wrapper around [`env_logger`](https://crates.io/crates/env_logger)
+- [`brk_mcp`](https://crates.io/crates/brk_mcp): A bridge for LLMs to access BRK
+- [`brk_parser`](https://crates.io/crates/brk_parser): A very fast Bitcoin block parser and iterator built on top of [`bitcoin-rust`](https://crates.io/crates/bitcoin)
+- [`brk_server`](https://crates.io/crates/brk_server): A server with an API for anything from BRK
+- [`brk_store`](https://crates.io/crates/brk_store): A thin wrapper around [`fjall`](https://crates.io/crates/fjall)
+- [`brk_structs`](https://crates.io/crates/brk_structs): Structs used throughout BRK
 
 ## Donate
 

TODO.md

@@ -0,0 +1,99 @@
+# 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)**
+    - remove configurable format (raw/compressed) and chose sane ones instead
+      - linear reads: compressed (height/date/... + txindex_to_height + txindex_to_version + ...)
+      - random reads: raw (outputindex_to_value + ...)
+    - add costs basis by percentile (percentile cost basis) back
+    - add support for per index computation
+    - fix min 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
+    - some datasets in `indexes` can probably be removed
+    - 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 chopiness datasets
+    - add utxo count, address count, supply data for  by reused addresses in groups by address type
+    - add more date ranges (3-6 months and more)
+    - add puell multiple dataset
+    - add pi cycle dataset
+    - add emas of price
+    - add 7d and 30d ema to sell side risk ratio and sopr
+    - don't compute everything for all cohorts as some datasets combinations are irrelevant
+      - addresses/utxos by amount don't need mvrvz for example
+    - 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
+    - add support for https (rustls)
+- __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
+      - separate z-score charts from "realized price" (with their own prices), have 4y, 2y and 1y
+      - price scale format depends on unit, hide digits for sats for example (if/when possible)
+    - table
+      - pagination
+      - exports (.json, .csv,…)
+    - search
+      - datasets add legend, and keywords ?
+      - height/address/txid
+    - api
+      - add api page with interactivity
+    - global
+      - **fix navigation/history**
+      - move share button to footer ?
+      - Use `ichart.createPane()` in wrapper
+      - improve behavior when local storage is unavailable
+        - by having a global state
+- __global__
+  - check `TODO`s in codebase

crates/brk/Cargo.toml

@@ -3,46 +3,55 @@ name = "brk"
 description.workspace = true
 license.workspace = true
 readme.workspace = true
+homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 version.workspace = true
+rust-version.workspace = true
+build = "build.rs"
 
 [features]
 full = [
-    "core",
+    "bundler",
     "computer",
-    "exit",
+    "error",
     "fetcher",
     "indexer",
+    "interface",
     "logger",
+    "mcp",
     "parser",
-    "query",
     "server",
-    "vec",
+    "store",
+    "structs",
 ]
-core = ["brk_core"]
+bundler = ["brk_bundler"]
 computer = ["brk_computer"]
-exit = ["brk_exit"]
+error = ["brk_error"]
 fetcher = ["brk_fetcher"]
 indexer = ["brk_indexer"]
+interface = ["brk_interface"]
 logger = ["brk_logger"]
+mcp = ["brk_mcp"]
 parser = ["brk_parser"]
-query = ["brk_query"]
 server = ["brk_server"]
-vec = ["brk_vec"]
+store = ["brk_store"]
+structs = ["brk_structs"]
 
 [dependencies]
+brk_bundler = { workspace = true, optional = true }
 brk_cli = { workspace = true }
-brk_core = { workspace = true, optional = true }
 brk_computer = { workspace = true, optional = true }
-brk_exit = { workspace = true, optional = true }
+brk_error = { workspace = true, optional = true }
 brk_fetcher = { workspace = true, optional = true }
 brk_indexer = { workspace = true, optional = true }
+brk_interface = { 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_server = { workspace = true, optional = true }
-brk_vec = { workspace = true, optional = true }
+brk_store = { workspace = true, optional = true }
+brk_structs = { workspace = true, optional = true }
 
 [package.metadata.docs.rs]
 all-features = true

crates/brk/README.md

@@ -0,0 +1,197 @@
+# brk
+
+**Main wrapper crate for the Bitcoin Research Kit (BRK)**
+
+The `brk` crate serves as the primary entry point for the Bitcoin Research Kit, providing a unified interface to all BRK components through feature flags. It enables developers to selectively include only the components they need while maintaining a consistent API.
+
+## What it provides
+
+- **Unified Access**: Single crate providing access to the entire BRK ecosystem
+- **Feature-based Selection**: Choose only the components you need
+- **Consistent Versioning**: All components versioned together for compatibility
+- **Simplified Dependencies**: Single dependency instead of multiple individual crates
+
+## Available Components
+
+### Core Data Pipeline
+- **`parser`** ([brk_parser](../brk_parser/)) - High-performance Bitcoin block parser
+- **`indexer`** ([brk_indexer](../brk_indexer/)) - Blockchain data indexer with dual storage
+- **`computer`** ([brk_computer](../brk_computer/)) - Analytics engine for computed datasets
+- **`interface`** ([brk_interface](../brk_interface/)) - Unified data query and formatting API
+
+### Infrastructure
+- **`structs`** ([brk_structs](../brk_structs/)) - Bitcoin-aware type system and data structures
+- **`error`** ([brk_error](../brk_error/)) - Centralized error handling
+- **`store`** ([brk_store](../brk_store/)) - Blockchain-aware key-value storage
+
+### External Integration
+- **`fetcher`** ([brk_fetcher](../brk_fetcher/)) - Bitcoin price data fetcher with multi-source fallback
+- **`server`** ([brk_server](../brk_server/)) - HTTP server with REST API
+- **`mcp`** ([brk_mcp](../brk_mcp/)) - Model Context Protocol for LLM integration
+
+### Utilities
+- **`cli`** ([brk_cli](../brk_cli/)) - Command line interface (always enabled)
+- **`logger`** ([brk_logger](../brk_logger/)) - Logging utilities
+- **`bundler`** ([brk_bundler](../brk_bundler/)) - Asset bundling for web interfaces
+
+## Usage
+
+### Full Installation
+
+```toml
+[dependencies]
+brk = { version = "0.0.88", features = ["full"] }
+```
+
+```rust
+use brk::*;
+
+// Access all components
+let config = cli::Config::load()?;
+let parser = parser::Parser::new(/* ... */);
+let indexer = indexer::Indexer::forced_import("./data")?;
+let computer = computer::Computer::forced_import("./data", &indexer, None)?;
+```
+
+### Selective Components
+
+```toml
+[dependencies]
+brk = { version = "0.0.88", features = ["parser", "indexer", "computer"] }
+```
+
+```rust
+use brk::{parser, indexer, computer};
+
+// Core data pipeline only
+let parser = parser::Parser::new(blocks_dir, output_dir, rpc);
+let mut indexer = indexer::Indexer::forced_import(output_dir)?;
+let mut computer = computer::Computer::forced_import(output_dir, &indexer, None)?;
+```
+
+### Minimal Setup
+
+```toml
+[dependencies]
+brk = { version = "0.0.88", features = ["structs", "parser"] }
+```
+
+```rust
+use brk::{structs, parser};
+
+// Just parsing and types
+let height = structs::Height::new(800_000);
+let parser = parser::Parser::new(blocks_dir, output_dir, rpc);
+```
+
+## Feature Flags
+
+| Feature | Description | Dependencies |
+|---------|-------------|--------------|
+| `full` | Enable all components | All crates |
+| `cli` | Command line interface | Always enabled |
+| `structs` | Core type system | Foundation for other crates |
+| `error` | Error handling | Used by most crates |
+| `parser` | Block parsing | `structs`, `error` |
+| `store` | Key-value storage | `structs`, `error` |
+| `indexer` | Blockchain indexing | `parser`, `store` |
+| `computer` | Analytics computation | `indexer`, `fetcher` (optional) |
+| `fetcher` | Price data fetching | `structs`, `error` |
+| `interface` | Data query API | `indexer`, `computer` |
+| `server` | HTTP server | `interface`, `mcp` |
+| `mcp` | LLM integration | `interface` |
+| `logger` | Logging utilities | Standalone |
+| `bundler` | Asset bundling | Standalone |
+
+## Common Usage Patterns
+
+### Complete BRK Instance
+
+```rust
+use brk::*;
+
+// Full data pipeline setup
+let config = cli::Config::load()?;
+let rpc = /* Bitcoin Core RPC client */;
+let parser = parser::Parser::new(config.blocks_dir, config.output_dir, rpc);
+let mut indexer = indexer::Indexer::forced_import(&config.output_dir)?;
+let mut computer = computer::Computer::forced_import(&config.output_dir, &indexer, None)?;
+let interface = interface::Interface::build(&indexer, &computer);
+let server = server::Server::new(interface, config.website_path);
+
+// Start server
+server.serve(true).await?;
+```
+
+### Data Analysis
+
+```rust
+use brk::{indexer, computer, interface};
+
+// Analysis-focused setup
+let indexer = indexer::Indexer::forced_import("./brk_data")?;
+let computer = computer::Computer::forced_import("./brk_data", &indexer, None)?;
+let interface = interface::Interface::build(&indexer, &computer);
+
+// Query data
+let params = interface::Params {
+    index: interface::Index::Height,
+    ids: vec!["price_usd", "difficulty"].into(),
+    rest: interface::ParamsOpt::default()
+        .set_from(-100)
+        .set_format(interface::Format::CSV),
+};
+
+let csv_data = interface.search_and_format(params)?;
+```
+
+### Custom Integration
+
+```rust
+use brk::{structs, parser, error};
+
+// Custom application with BRK components
+fn analyze_blocks() -> error::Result<()> {
+    let parser = parser::Parser::new(blocks_dir, output_dir, rpc);
+    
+    parser.parse(None, None)
+        .iter()
+        .take(1000)  // First 1000 blocks
+        .for_each(|(height, block, hash)| {
+            println!("Block {}: {} transactions", height, block.txdata.len());
+        });
+    
+    Ok(())
+}
+```
+
+## Version Compatibility
+
+All BRK crates are released together with synchronized versions. When using the `brk` wrapper crate, you're guaranteed compatibility between all components.
+
+- **Current version**: 0.0.88
+- **Rust MSRV**: 1.89+
+- **Bitcoin Core**: v25.0 - v29.0
+
+## Performance Characteristics
+
+The `brk` crate itself adds no runtime overhead - it simply re-exports the underlying crates. Performance characteristics depend on which components you use:
+
+- **Full pipeline**: ~13-15 hours initial sync, ~40GB storage overhead
+- **Parser only**: ~4 minutes to parse entire blockchain
+- **Indexer only**: ~7-8 hours to index blockchain, ~5-6GB RAM usage
+- **Server**: Low latency API responses with caching and compression
+
+## Dependencies
+
+The `brk` crate's dependencies are determined by enabled features. Core dependencies include:
+
+- `brk_cli` - Always included for configuration and CLI support
+- Individual `brk_*` crates based on enabled features
+- Transitive dependencies from enabled components
+
+For specific dependency information, see individual crate READMEs.
+
+---
+
+*This README was generated by Claude Code*

crates/brk/build.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let profile = std::env::var("PROFILE").unwrap_or_default();
+
+    if profile == "release" {
+        println!("cargo:rustc-flag=-C");
+        println!("cargo:rustc-flag=target-cpu=native");
+    }
+}

crates/brk/flamegraph.sh

@@ -0,0 +1 @@
+sudo cargo flamegraph --profile profiling --root

crates/brk/samply.sh

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

crates/brk/src/lib.rs

@@ -1,16 +1,23 @@
-#![doc = include_str!(concat!("../", env!("CARGO_PKG_README")))]
+#![doc = include_str!("../README.md")]
 
-#[cfg(feature = "core")]
+#[cfg(feature = "bundler")]
 #[doc(inline)]
-pub use brk_core as core;
+pub use brk_bundler as bundler;
+
+#[doc(inline)]
+pub use brk_cli as cli;
+
+#[cfg(feature = "structs")]
+#[doc(inline)]
+pub use brk_structs as structs;
 
 #[cfg(feature = "computer")]
 #[doc(inline)]
 pub use brk_computer as computer;
 
-#[cfg(feature = "exit")]
+#[cfg(feature = "error")]
 #[doc(inline)]
-pub use brk_exit as exit;
+pub use brk_error as error;
 
 #[cfg(feature = "fetcher")]
 #[doc(inline)]
@@ -24,18 +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 = "vec")]
+#[cfg(feature = "store")]
 #[doc(inline)]
-pub use brk_vec as vec;
+pub use brk_store as store;

crates/brk_bundler/Cargo.toml

@@ -0,0 +1,18 @@
+[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
+rust-version.workspace = true
+build = "build.rs"
+
+[dependencies]
+log = { workspace = true }
+notify = "8.2.0"
+brk_rolldown = "0.1.4"
+# brk_rolldown = { path = "../../../rolldown/crates/rolldown"}
+sugar_path = "1.2.0"
+tokio = { workspace = true }

crates/brk_bundler/README.md

@@ -0,0 +1,186 @@
+# brk_bundler
+
+**Asset bundling for BRK web interfaces using Rolldown**
+
+`brk_bundler` provides JavaScript/TypeScript bundling capabilities for BRK's web interfaces. It's a thin wrapper around Rolldown (Rust-based Rollup alternative) with BRK-specific configuration for building optimized web assets with file watching and automatic rebuilding.
+
+## What it provides
+
+- **JavaScript Bundling**: Modern ES modules bundling with minification
+- **File Watching**: Automatic rebuilding on source file changes
+- **Asset Processing**: Copies and processes static assets
+- **Version Injection**: Automatic version string replacement in service workers
+- **Development Mode**: Live rebuilding for rapid development
+
+## Key Features
+
+### Bundling Capabilities
+- **ES Module Support**: Modern JavaScript bundling with tree-shaking
+- **Minification**: Automatic code minification for production builds
+- **Source Maps**: Generated source maps for debugging
+- **Entry Point Processing**: Configurable entry points with hashed output names
+
+### File System Operations
+- **Directory Copying**: Copies entire source directories to distribution
+- **Selective Processing**: Special handling for specific file types
+- **Path Resolution**: Automatic path resolution and asset linking
+
+### Development Features
+- **Hot Rebuilding**: Automatic rebuilds on file changes
+- **Watch Mode**: Monitors source files and triggers rebuilds
+- **Version Replacement**: Injects build version into service workers
+
+## Usage
+
+### Basic Bundling
+
+```rust
+use brk_bundler::bundle;
+use std::path::Path;
+
+// Bundle without watching (production)
+let websites_path = Path::new("./websites");
+let source_folder = "default";
+let dist_path = bundle(websites_path, source_folder, false).await?;
+
+println!("Bundled to: {:?}", dist_path);
+```
+
+### Development Mode with Watching
+
+```rust
+// Bundle with file watching (development)
+let dist_path = bundle(websites_path, "default", true).await?;
+
+// Bundler now watches for changes and rebuilds automatically
+// This will run in the background until the process exits
+```
+
+### Integration with BRK CLI
+
+```rust
+// Typically called from brk_cli when serving websites
+async fn setup_website(config: &Config) -> Result<PathBuf> {
+    let websites_path = config.websites_path();
+    let source_folder = match config.website_mode {
+        WebsiteMode::Default => "default",
+        WebsiteMode::Custom => "custom",
+        WebsiteMode::None => return Ok(PathBuf::new()),
+    };
+    
+    // Bundle the website assets
+    let dist_path = bundle(websites_path, source_folder, config.dev_mode).await?;
+    
+    Ok(dist_path)
+}
+```
+
+## File Structure
+
+The bundler expects this directory structure:
+
+```
+websites/
+├── default/                 # Default website source
+│   ├── index.html          # Main HTML file
+│   ├── service-worker.js   # Service worker (version injected)
+│   ├── scripts/            # JavaScript/TypeScript source
+│   │   ├── entry.js        # Main entry point
+│   │   ├── main.js         # Application logic
+│   │   └── ...             # Other JS modules
+│   └── assets/             # Static assets
+└── dist/                   # Generated output directory
+    ├── index.html          # Processed HTML with updated script references
+    ├── service-worker.js   # Service worker with version injected
+    ├── scripts/            # Bundled and minified JavaScript
+    │   └── main-[hash].js  # Hashed output file
+    └── assets/             # Copied static assets
+```
+
+## Bundling Process
+
+1. **Clean**: Removes existing `dist/` directory
+2. **Copy**: Copies all source files to `dist/`
+3. **Bundle JavaScript**: 
+   - Processes `scripts/entry.js` as entry point
+   - Generates minified bundle with source maps
+   - Creates hashed filename for cache busting
+4. **Process HTML**: Updates script references to hashed filenames
+5. **Process Service Worker**: Injects current version string
+6. **Watch** (if enabled): Monitors for file changes and rebuilds
+
+## Configuration
+
+The bundler uses Rolldown with these optimized settings:
+
+```rust
+BundlerOptions {
+    input: Some(vec![source_entry.into()]),    // scripts/entry.js
+    dir: Some("./dist/scripts".to_string()),   // Output directory
+    cwd: Some(websites_path),                  // Working directory
+    minify: Some(RawMinifyOptions::Bool(true)), // Enable minification
+    sourcemap: Some(SourceMapType::File),      // Generate source maps
+    ..Default::default()
+}
+```
+
+## File Watching
+
+In watch mode, the bundler monitors:
+
+- **Source files**: Non-script files are copied on change
+- **JavaScript files**: Trigger full rebuild via Rolldown watcher
+- **HTML files**: Processed to update script references
+- **Service worker**: Version injection on changes
+
+### Watch Events Handled
+
+- `Create` - New files added
+- `Modify` - Existing files changed
+- Ignores `Delete` and other events
+
+## Version Injection
+
+Service workers get automatic version injection:
+
+```javascript
+// In source service-worker.js
+const VERSION = '__VERSION__';
+
+// After bundling
+const VERSION = 'v0.0.88';
+```
+
+This enables proper cache invalidation across releases.
+
+## Performance Features
+
+- **Async Operations**: All bundling operations are async
+- **Incremental Builds**: Only rebuilds changed files in watch mode
+- **Parallel Processing**: Uses Tokio for concurrent file operations
+- **Efficient Copying**: Direct file system operations
+
+## Error Handling
+
+- **Graceful Failures**: Logs errors but continues watching
+- **Path Resolution**: Automatic path absolutization and validation
+- **File System Errors**: Proper error propagation with context
+
+## Dependencies
+
+- `brk_rolldown` - Rust-based Rollup bundler
+- `notify` - File system watching
+- `tokio` - Async runtime for file operations
+- `sugar_path` - Path manipulation utilities
+- `log` - Error logging
+
+## Integration Points
+
+The bundler integrates with:
+- **brk_cli**: Called during website setup
+- **brk_server**: Serves bundled assets
+- **Development workflow**: Provides live rebuilding
+
+---
+
+*This README was generated by Claude Code*

crates/brk_bundler/build.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let profile = std::env::var("PROFILE").unwrap_or_default();
+
+    if profile == "release" {
+        println!("cargo:rustc-flag=-C");
+        println!("cargo:rustc-flag=target-cpu=native");
+    }
+}

crates/brk_bundler/src/lib.rs

@@ -0,0 +1,149 @@
+#![doc = include_str!("../README.md")]
+
+use std::{
+    fs, io,
+    path::{Path, PathBuf},
+    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<PathBuf> {
+    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"))
+            && let Some(start) = entry.find("main")
+            && 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(dist_path);
+    }
+
+    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(dist_path)
+}
+
+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(())
+}

crates/brk_cli/Cargo.toml

@@ -1,29 +1,34 @@
 [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 BRK instance"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
+homepage.workspace = true
 repository.workspace = true
+rust-version.workspace = true
+build = "build.rs"
 
 [dependencies]
+bitcoincore-rpc = { workspace = true }
+brk_bundler = { workspace = true }
 brk_computer = { workspace = true }
-brk_core = { workspace = true }
-brk_exit = { workspace = true }
 brk_fetcher = { workspace = true }
 brk_indexer = { workspace = true }
+brk_interface = { 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 }
-clap_derive = { workspace = true }
-color-eyre = { workspace = true }
+vecdb = { workspace = true }
+clap = { version = "4.5.45", features = ["string"] }
+clap_derive = "4.5.45"
+color-eyre = "0.6.5"
 log = { workspace = true }
+minreq = { workspace = true }
 serde = { workspace = true }
-tabled = { workspace = true }
-toml = "0.8.22"
+tokio = { workspace = true }
+toml = "0.9.5"
+zip = { version = "4.5.0", default-features = false, features = ["deflate"] }
 
 [[bin]]
 name = "brk"

crates/brk_cli/README.md

@@ -1,94 +1,189 @@
-# BRK Cli
+# brk_cli
 
-<p align="left">
-  <a href="https://github.com/bitcoinresearchkit/brk">
-    <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/bitcoinresearchkit/brk?style=social">
-  </a>
-  <a href="https://kibo.money">
-    <img alt="kibo.money" src="https://img.shields.io/badge/showcase-kib%C5%8D.money-orange">
-  </a>
-  <a href="https://github.com/bitcoinresearchkit/brk/blob/main/LICENSE.md">
-    <img src="https://img.shields.io/crates/l/brk" alt="License" />
-  </a>
-  <a href="https://crates.io/crates/brk_cli">
-    <img src="https://img.shields.io/crates/v/brk_cli" alt="Version" />
-  </a>
-  <a href="https://docs.rs/brk_cli">
-    <img src="https://img.shields.io/docsrs/brk_cli" alt="Documentation" />
-  </a>
-  <img src="https://img.shields.io/crates/size/brk_cli" alt="Size" />
-  <a href="https://deps.rs/crate/brk_cli">
-    <img src="https://deps.rs/crate/brk_cli/latest/status.svg" alt="Dependency status">
-  </a>
-  <a href="https://discord.gg/HaR3wpH3nr">
-    <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
-  </a>
-  <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
-    <img src="https://img.shields.io/badge/nostr-purple?link=https%3A%2F%2Fprimal.net%2Fp%2Fnprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6" alt="Nostr" />
-  </a>
-  <a href="https://bsky.app/profile/bitcoinresearchkit.org">
-    <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
-  </a>
-  <a href="https://x.com/brkdotorg">
-    <img src="https://img.shields.io/badge/x.com-black" alt="X" />
-  </a>
-</p>
+**Command line interface for running complete BRK instances**
 
-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.
+`brk_cli` provides the main command-line interface for operating the Bitcoin Research Kit. It orchestrates the complete data pipeline from Bitcoin Core block parsing through analytics computation to HTTP API serving, with automatic configuration management and graceful operation.
 
-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)).
+## What it provides
 
-## Requirements
+- **Complete Pipeline Orchestration**: Coordinates parser, indexer, computer, and server components
+- **Automatic Configuration**: Saves settings to `~/.brk/config.toml` for consistent operation
+- **Continuous Operation**: Handles blockchain updates and incremental processing
+- **Web Interface Options**: Configurable website serving (none, default, custom)
+- **Graceful Shutdown**: Ctrl+C handling with proper cleanup
 
-### Hardware
+## Key Features
 
-#### Recommended
+### Pipeline Management
+- **Automatic dependency handling**: Ensures Bitcoin Core sync before processing
+- **Incremental updates**: Only processes new blocks since last run
+- **Error recovery**: Automatic retry logic and graceful error handling
+- **Resource management**: Optimized memory usage and disk I/O
 
-- [Latest base model Mac mini](https://www.apple.com/mac-mini/)
-- [Thunderbolt 4 SSD enclosure](https://satechi.net/products/usb4-nvme-ssd-pro-enclosure/Z2lkOi8vc2hvcGlmeS9Qcm9kdWN0VmFyaWFudC80MDE4ODQ3MDA2NzI4OA==?queryID=7961465089021ee203a60db7e62e90d2)
-- [2 TB NVMe SSD](https://shop.sandisk.com/products/ssd/internal-ssd/wd-black-sn850x-nvme-ssd?sku=WDS200T2X0E-00BCA0)
+### Configuration System
+- **Auto-save configuration**: All CLI options saved to persistent config
+- **Flexible paths**: Configurable Bitcoin directory, blocks directory, and output directory
+- **RPC authentication**: Cookie file or username/password authentication
+- **Data source options**: Configurable price fetching and exchange APIs
 
-#### Minimum
+### Operation Modes
+- **Initial sync**: Full blockchain processing from genesis
+- **Continuous operation**: Real-time processing of new blocks
+- **Update mode**: Resume from last processed block
+- **Server mode**: HTTP API with optional web interface
 
-To be determined
-
-### Software
-
-- [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`
-
-## 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)).
-
-### Cargo
+## Installation
 
+### Binary Release
 ```bash
-# Install
-cargo install brk # or `cargo install brk_cli`, the result is the same
-
-# Update
-cargo install brk # or `cargo install-update -a` if you have `cargo-update` installed
+# Download from GitHub releases
+# https://github.com/bitcoinresearchkit/brk/releases/latest
 ```
 
-### Source
+### Via Cargo
+```bash
+cargo install brk --locked
+```
 
+### From Source
 ```bash
 git clone https://github.com/bitcoinresearchkit/brk.git
-cd brk/crates/brk
-cargo run -r
+cd brk && cargo build --release
 ```
 
 ## Usage
 
-Run `brk -h` to view each available command and their respective description.
+### First Run (Configuration Setup)
 
-`-h` works also for commands, which mean that `brk run -h` will explain all the parameters of `brk run` for example.
+```bash
+# Basic setup with default options
+brk --brkdir ./my_brk_data
 
-Every parameter set for `brk run` will be saved at `~/.brk/config.toml`, which will allow you to simply run `brk run` next time.
+# Full configuration
+brk --bitcoindir ~/.bitcoin \
+    --brkdir ./brk_data \
+    --fetch true \
+    --exchanges true \
+    --website default
+```
 
-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/
+### Subsequent Runs
+
+```bash
+# Uses saved configuration from ~/.brk/config.toml
+brk
+
+# Override specific options
+brk --website none --fetch false
+```
+
+### Command Line Options
+
+```bash
+brk --help
+```
+
+## Configuration Reference
+
+All options are automatically saved to `~/.brk/config.toml`:
+
+### Core Paths
+- `--bitcoindir <PATH>` - Bitcoin Core directory (default: `~/.bitcoin`)
+- `--blocksdir <PATH>` - Block files directory (default: `bitcoindir/blocks`)
+- `--brkdir <PATH>` - BRK output directory (default: `~/.brk`)
+
+### Data Sources
+- `--fetch <BOOL>` - Enable price data fetching (default: `true`)
+- `--exchanges <BOOL>` - Use exchange APIs for prices (default: `true`)
+
+### Web Interface
+- `--website <OPTION>` - Web interface mode:
+  - `none` - API only, no web interface
+  - `default` - Built-in web interface from `websites/default/`
+  - `custom` - Serve custom website from `websites/custom/`
+
+### Bitcoin Core RPC
+- `--rpcconnect <IP>` - RPC host (default: `localhost`)
+- `--rpcport <PORT>` - RPC port (default: `8332`)
+- `--rpccookiefile <PATH>` - Cookie authentication file
+- `--rpcuser <USERNAME>` - Username authentication
+- `--rpcpassword <PASSWORD>` - Password authentication
+
+## Operation Flow
+
+1. **Configuration Loading**: Loads saved config from `~/.brk/config.toml`
+2. **Bitcoin Core Connection**: Establishes RPC connection and waits for sync
+3. **Data Pipeline Initialization**: Sets up parser, indexer, computer, and interface
+4. **Processing Loop**:
+   - Index new blocks from Bitcoin Core
+   - Compute analytics on new data
+   - Update cached data
+5. **Server Startup**: Launches HTTP API with optional web interface
+6. **Continuous Operation**: Monitors for new blocks and processes incrementally
+
+## System Requirements
+
+- **Bitcoin Core**: Fully synced node with RPC enabled
+- **Storage**: ~32% of blockchain size (~233GB as of 2025)
+- **Memory**:
+  - Peak: ~7-8GB during initial indexing
+  - Steady state: ~4-5GB during operation
+- **OS**: macOS or Linux
+  - Ubuntu: `sudo apt install libssl-dev pkg-config`
+
+## Performance Characteristics
+
+### Initial Sync
+- **Full blockchain processing**: ~13-15 hours total
+- **Parser phase**: ~4 minutes for block parsing
+- **Indexer phase**: ~7-8 hours for data indexing
+- **Computer phase**: ~6-7 hours for analytics computation
+
+### Continuous Operation
+- **New block processing**: 3-5 seconds per block
+- **API response times**: Typically <100ms with caching
+- **Memory usage**: Stable ~4-5GB during normal operation
+
+## Configuration File
+
+Example `~/.brk/config.toml`:
+```toml
+bitcoindir = "/Users/username/.bitcoin"
+blocksdir = "/Users/username/.bitcoin/blocks"
+brkdir = "/Users/username/brk_data"
+fetch = true
+exchanges = true
+website = "default"
+rpcconnect = "localhost"
+rpcport = 8332
+rpccookiefile = "/Users/username/.bitcoin/.cookie"
+```
+
+## Error Handling
+
+- **Bitcoin Core sync**: Waits for node sync before processing
+- **RPC connection**: Automatic retry logic for connection issues
+- **Processing errors**: Graceful error handling with detailed logging
+- **Graceful shutdown**: Ctrl+C handling with proper cleanup and state saving
+
+## Logging
+
+Logs are written to `~/.brk/brk.log` with colored console output:
+- Request/response logging with timing
+- Processing progress indicators
+- Error reporting and debugging information
+
+## Dependencies
+
+- `brk_parser` - Bitcoin block parsing
+- `brk_indexer` - Blockchain data indexing
+- `brk_computer` - Analytics computation
+- `brk_interface` - Data query interface
+- `brk_server` - HTTP API server
+- `brk_logger` - Logging utilities
+- `bitcoincore_rpc` - Bitcoin Core RPC client
+- `color_eyre` - Enhanced error reporting
+
+---
+
+*This README was generated by Claude Code*

crates/brk_cli/build.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let profile = std::env::var("PROFILE").unwrap_or_default();
+
+    if profile == "release" {
+        println!("cargo:rustc-flag=-C");
+        println!("cargo:rustc-flag=target-cpu=native");
+    }
+}

crates/brk_cli/src/bridge.rs

@@ -1,18 +1,19 @@
 use std::{fs, io, path::Path};
 
-use brk_query::{Index, Query};
+use brk_interface::{Index, Interface};
+use brk_server::VERSION;
 
-use crate::Website;
+use crate::website::Website;
 
 const SCRIPTS: &str = "scripts";
 
 #[allow(clippy::upper_case_acronyms)]
-pub trait DTS {
-    fn generate_dts_file(&self, website: Website, websites_path: &Path) -> io::Result<()>;
+pub trait Bridge {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()>;
 }
 
-impl DTS for Query<'static> {
-    fn generate_dts_file(&self, website: Website, websites_path: &Path) -> io::Result<()> {
+impl Bridge for Interface<'static> {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()> {
         if website.is_none() {
             return Ok(());
         }
@@ -31,10 +32,15 @@ impl DTS for Query<'static> {
 
         let indexes = Index::all();
 
-        let mut contents = "//
+        let mut contents = format!(
+            "//
 // File auto-generated, any modifications will be overwritten
-//\n\n"
-            .to_string();
+//
+
+export const VERSION = \"v{VERSION}\";
+
+"
+        );
 
         contents += &indexes
             .iter()
@@ -47,7 +53,7 @@ impl DTS for Query<'static> {
             .join("\n");
 
         contents += &format!(
-            "\n\n/** @typedef {{{}}} Index */",
+            "\n\n/** @typedef {{{}}} Index */\n",
             indexes
                 .iter()
                 .map(|i| i.to_string())
@@ -55,22 +61,37 @@ impl DTS for Query<'static> {
                 .join(" | ")
         );
 
-        contents += "\n\nexport function createVecIdToIndexes() {\n";
+        contents += "
+/** @typedef {ReturnType<typeof createIndexes>} Indexes */
 
-        // contents += &indexes
-        //     .iter()
-        //     .enumerate()
-        //     .map(|(i_of_i, i)| {
-        //         // let lowered = i.to_string().to_lowercase();
-        //         format!("  const {i} = /** @satisfies {{{i}}} */ ({i_of_i});",)
-        //     })
-        //     .collect::<Vec<_>>()
-        //     .join("\n");
+export function createIndexes() {
+  return {
+";
 
-        contents += "\n\n  return /** @type {const} */ ({\n";
+        contents += &indexes
+            .iter()
+            .enumerate()
+            .map(|(i_of_i, i)| {
+                let lowered = i.to_string().to_lowercase();
+                format!("    {lowered}: /** @satisfies {{{i}}} */ ({i_of_i}),",)
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
 
-        self.vec_trees
-            .id_to_index_to_vec
+        contents += "  };\n}\n";
+
+        contents += "
+/** @typedef {ReturnType<typeof createVecIdToIndexes>} VecIdToIndexes
+/** @typedef {keyof VecIdToIndexes} VecId */
+
+/**
+ * @returns {Record<any, number[]>}
+ */
+export function createVecIdToIndexes() {
+  return {
+";
+
+        self.id_to_index_to_vec()
             .iter()
             .for_each(|(id, index_to_vec)| {
                 let indexes = index_to_vec
@@ -83,11 +104,7 @@ impl DTS for Query<'static> {
                 contents += &format!("    \"{id}\": [{indexes}],\n");
             });
 
-        contents += "  });\n";
-        contents.push('}');
-
-        contents += "\n/** @typedef {ReturnType<typeof createVecIdToIndexes>} VecIdToIndexes */";
-        contents += "\n/** @typedef {keyof VecIdToIndexes} VecId */\n";
+        contents += "  };\n}\n";
 
         fs::write(path, contents)
     }

crates/brk_cli/src/config.rs

@@ -1,184 +1,87 @@
 use std::{
     fs,
     path::{Path, PathBuf},
-    thread::{self, sleep},
-    time::Duration,
 };
 
-use brk_computer::Computer;
-use brk_core::{default_bitcoin_path, default_brk_path, dot_brk_path};
-use brk_exit::Exit;
+use bitcoincore_rpc::{self, Auth, Client};
 use brk_fetcher::Fetcher;
-use brk_indexer::Indexer;
-use brk_parser::rpc::{self, Auth, Client, RpcApi};
-use brk_server::{Server, Website, tokio};
-use brk_vec::Computation;
-use clap_derive::{Parser, ValueEnum};
+use clap::Parser;
+use clap_derive::Parser;
 use color_eyre::eyre::eyre;
-use log::info;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 
-pub fn run(config: RunConfig) -> color_eyre::Result<()> {
-    let config = RunConfig::import(Some(config))?;
+use crate::{default_bitcoin_path, default_brk_path, dot_brk_path, website::Website};
 
-    let rpc = config.rpc()?;
-
-    let exit = Exit::new();
-
-    let parser = brk_parser::Parser::new(config.blocksdir(), rpc);
-
-    let compressed = config.compressed();
-
-    let mut indexer = Indexer::new(&config.outputsdir(), compressed, config.check_collisions())?;
-    indexer.import_stores()?;
-    indexer.import_vecs()?;
-
-    let wait_for_synced_node = || -> color_eyre::Result<()> {
-        let is_synced = || -> color_eyre::Result<bool> {
-            let info = rpc.get_blockchain_info()?;
-            Ok(info.headers == info.blocks)
-        };
-
-        if !is_synced()? {
-            info!("Waiting for node to be synced...");
-            while !is_synced()? {
-                sleep(Duration::from_secs(1))
-            }
-        }
-
-        Ok(())
-    };
-
-    let f = move || -> color_eyre::Result<()> {
-        let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), compressed);
-        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()
-}
+const DOWNLOADS: &str = "downloads";
 
 #[derive(Parser, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
-pub struct RunConfig {
+#[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>,
 
-    /// 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 = 'C', 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 = "BOOL")]
-    compressed: Option<bool>,
-
-    /// Activate fetching prices from exchanges APIs and the computation of all related datasets, default: true, saved
-    #[arg(short, long, value_name = "BOOL")]
+    /// Activate fetching prices from BRK's API and the computation of all price 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: kibo.money, saved
+    /// Activate fetching prices from exchanges APIs if `fetch` is also set to `true`, default: true, saved
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(long, value_name = "BOOL")]
+    exchanges: Option<bool>,
+
+    /// Website served by the server, 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
-    #[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")]
+    #[serde(default, deserialize_with = "default_on_error")]
+    #[arg(skip)]
     check_collisions: Option<bool>,
 }
 
-impl RunConfig {
-    pub fn import(config_args: Option<RunConfig>) -> color_eyre::Result<Self> {
+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);
@@ -200,16 +103,12 @@ impl RunConfig {
                 config_saved.brkdir = Some(brkdir);
             }
 
-            if let Some(mode) = config_args.mode.take() {
-                config_saved.mode = Some(mode);
-            }
-
             if let Some(fetch) = config_args.fetch.take() {
                 config_saved.fetch = Some(fetch);
             }
 
-            if let Some(compressed) = config_args.compressed.take() {
-                config_saved.compressed = Some(compressed);
+            if let Some(exchanges) = config_args.exchanges.take() {
+                config_saved.exchanges = Some(exchanges);
             }
 
             if let Some(website) = config_args.website.take() {
@@ -236,15 +135,11 @@ impl RunConfig {
                 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() {
+            if config_args != Config::default() {
                 dbg!(config_args);
                 panic!("Didn't consume the full config")
             }
@@ -256,19 +151,6 @@ impl RunConfig {
 
         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)
     }
 
@@ -296,7 +178,9 @@ impl RunConfig {
 
         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."
+                "Unsuccessful authentication with the RPC client.
+First make sure that `bitcoind` is running. If it is then please either set --rpccookiefile or --rpcuser and --rpcpassword as the default values seemed to have failed.
+Finally, you can run the program with '-h' for help."
             );
             std::process::exit(1);
         }
@@ -304,7 +188,7 @@ impl RunConfig {
 
     fn read(path: &Path) -> Self {
         fs::read_to_string(path).map_or_else(
-            |_| RunConfig::default(),
+            |_| Config::default(),
             |contents| toml::from_str(&contents).unwrap_or_default(),
         )
     }
@@ -314,7 +198,7 @@ impl RunConfig {
     }
 
     pub fn rpc(&self) -> color_eyre::Result<&'static Client> {
-        Ok(Box::leak(Box::new(rpc::Client::new(
+        Ok(Box::leak(Box::new(Client::new(
             &format!(
                 "http://{}:{}",
                 self.rpcconnect().unwrap_or(&"localhost".to_string()),
@@ -347,10 +231,6 @@ impl RunConfig {
         self.rpcport
     }
 
-    pub fn delay(&self) -> Option<u64> {
-        self.delay
-    }
-
     pub fn bitcoindir(&self) -> PathBuf {
         self.bitcoindir
             .as_ref()
@@ -370,22 +250,12 @@ impl RunConfig {
             .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")
+        self.brkdir().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)
+    pub fn downloads_dir(&self) -> PathBuf {
+        dot_brk_path().join(DOWNLOADS)
     }
 
     fn path_cookiefile(&self) -> PathBuf {
@@ -414,24 +284,20 @@ impl RunConfig {
     }
 
     pub fn website(&self) -> Website {
-        self.website.unwrap_or(Website::KiboMoney)
+        self.website.unwrap_or(Website::Default)
     }
 
     pub fn fetch(&self) -> bool {
         self.fetch.is_none_or(|b| b)
     }
 
+    pub fn exchanges(&self) -> bool {
+        self.exchanges.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 compressed(&self) -> bool {
-        self.compressed.is_none_or(|b| b)
+            .then(|| Fetcher::import(self.exchanges(), Some(self.harsdir().as_path())).unwrap())
     }
 
     pub fn check_collisions(&self) -> bool {
@@ -439,23 +305,13 @@ impl RunConfig {
     }
 }
 
-#[derive(
-    Default,
-    Debug,
-    Clone,
-    Copy,
-    Parser,
-    ValueEnum,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-)]
-pub enum Mode {
-    #[default]
-    All,
-    Processor,
-    Server,
+fn default_on_error<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de> + Default,
+{
+    match T::deserialize(deserializer) {
+        Ok(v) => Ok(v),
+        Err(_) => Ok(T::default()),
+    }
 }

crates/brk_cli/src/lib.rs

@@ -1,42 +1,146 @@
-use std::fs;
+#![doc = include_str!("../README.md")]
 
-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};
+use std::{
+    fs,
+    io::Cursor,
+    path::Path,
+    thread::{self, sleep},
+    time::Duration,
+};
 
-mod query;
-mod run;
+use bitcoincore_rpc::{self, RpcApi};
+use brk_bundler::bundle;
+use brk_computer::Computer;
+use brk_indexer::Indexer;
+use brk_interface::Interface;
+use brk_server::{Server, VERSION};
+use log::info;
+use vecdb::Exit;
 
-#[derive(Parser)]
-#[command(version, about)]
-#[command(propagate_version = true)]
-struct Cli {
-    #[command(subcommand)]
-    command: Commands,
-}
+mod bridge;
+mod config;
+mod paths;
+mod website;
 
-#[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 crate::{bridge::Bridge, config::Config, paths::*};
 
 pub fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
 
     fs::create_dir_all(dot_brk_path())?;
 
-    brk_logger::init(Some(&dot_brk_log_path()));
+    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()
+}
+
+pub fn run() -> color_eyre::Result<()> {
+    let config = Config::import()?;
+
+    let rpc = config.rpc()?;
+
+    let exit = Exit::new();
+    exit.set_ctrlc_handler();
+
+    let parser = brk_parser::Parser::new(config.blocksdir(), config.brkdir(), rpc);
+
+    let mut indexer = Indexer::forced_import(&config.brkdir())?;
+
+    let wait_for_synced_node = |rpc_client: &bitcoincore_rpc::Client| -> color_eyre::Result<()> {
+        let is_synced = || -> color_eyre::Result<bool> {
+            let info = rpc_client.get_blockchain_info()?;
+            Ok(info.headers == info.blocks)
+        };
+
+        if !is_synced()? {
+            info!("Waiting for node to be synced...");
+            while !is_synced()? {
+                sleep(Duration::from_secs(1))
+            }
+        }
+
+        Ok(())
+    };
+
+    let mut computer = Computer::forced_import(&config.brkdir(), &indexer, config.fetcher())?;
+
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()?
+        .block_on(async {
+            let interface = Interface::build(&indexer, &computer);
+
+            let website = config.website();
+
+            let downloads_path = config.downloads_dir();
+
+            let bundle_path = if website.is_some() {
+                let websites_dev_path = Path::new("../../websites");
+
+                let websites_path = if fs::exists(websites_dev_path)? {
+                    websites_dev_path.to_path_buf()
+                } else {
+                    let downloaded_websites_path =
+                        downloads_path.join(format!("brk-{VERSION}")).join("websites");
+
+                    if !fs::exists(&downloaded_websites_path)? {
+                        info!("Downloading websites from Github...");
+
+                        let url = format!(
+                            "https://github.com/bitcoinresearchkit/brk/archive/refs/tags/v{VERSION}.zip",
+                        );
+
+                        let response = minreq::get(url).send()?;
+                        let bytes = response.as_bytes();
+                        let cursor = Cursor::new(bytes);
+
+                        let mut zip = zip::ZipArchive::new(cursor).unwrap();
+
+                        zip.extract(downloads_path).unwrap();
+                    }
+
+                    downloaded_websites_path
+                };
+
+                interface.generate_bridge_file(website, websites_path.as_path())?;
+
+                Some(bundle(&websites_path, website.to_folder_name(), true).await?)
+            } else {
+                None
+            };
+
+            let server = Server::new(
+                interface,
+                bundle_path,
+            );
+
+            tokio::spawn(async move {
+                server.serve(true).await.unwrap();
+            });
+
+            sleep(Duration::from_secs(1));
+
+            loop {
+                wait_for_synced_node(rpc)?;
+
+                let block_count = rpc.get_block_count()?;
+
+                info!("{} blocks found.", block_count + 1);
+
+                let starting_indexes =
+                    indexer.index(&parser, rpc, &exit, config.check_collisions()).unwrap();
+
+                computer.compute(&indexer, starting_indexes, &exit).unwrap();
+
+                info!("Waiting for new blocks...");
+
+                while block_count == rpc.get_block_count()? {
+                    sleep(Duration::from_secs(1))
+                }
+            }
+        })
 }

crates/brk_cli/src/query.rs

@@ -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 compressed = config.compressed();
-
-    let mut indexer = Indexer::new(&config.outputsdir(), compressed, config.check_collisions())?;
-    indexer.import_vecs()?;
-
-    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), compressed);
-    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(())
-}

crates/brk_cli/src/website.rs

@@ -1,14 +1,10 @@
 use clap_derive::ValueEnum;
 use serde::{Deserialize, Serialize};
 
-#[derive(
-    Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize, ValueEnum,
-)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize, ValueEnum)]
 pub enum Website {
-    #[default]
     None,
-    #[value(name = "kibo.money")]
-    KiboMoney,
+    Default,
     Custom,
 }
 
@@ -21,10 +17,10 @@ impl Website {
         !self.is_none()
     }
 
-    pub fn to_folder_name(&self) -> &str {
+    pub fn to_folder_name(self) -> &'static str {
         match self {
             Self::Custom => "custom",
-            Self::KiboMoney => "kibo.money",
+            Self::Default => "default",
             Self::None => unreachable!(),
         }
     }

crates/brk_computer/Cargo.toml

@@ -1,27 +1,31 @@
 [package]
 name = "brk_computer"
-description = "A Bitcoin dataset computer, built on top of brk_indexer"
+description = "A Bitcoin dataset computer built on top of brk_indexer"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
+homepage.workspace = true
 repository.workspace = true
+rust-version.workspace = true
+build = "build.rs"
 
 [dependencies]
-brk_core = { workspace = true }
-brk_exit = { workspace = true }
+bitcoin = { workspace = true }
+bitcoincore-rpc = { workspace = true }
+brk_structs = { workspace = true }
+brk_error = { workspace = true }
 brk_fetcher = { workspace = true }
 brk_indexer = { workspace = true }
 brk_logger = { workspace = true }
 brk_parser = { workspace = true }
-brk_vec = { workspace = true }
-clap = { workspace = true }
-clap_derive = { workspace = true }
-color-eyre = { workspace = true }
+vecdb = { workspace = true }
 derive_deref = { workspace = true }
-fjall = { workspace = true }
 log = { workspace = true }
+pco = "0.4.6"
 rayon = { workspace = true }
 serde = { workspace = true }
-serde_json = { workspace = true }
 zerocopy = { workspace = true }
 zerocopy-derive = { workspace = true }
+
+[package.metadata.cargo-machete]
+ignored = ["zerocopy"]

crates/brk_computer/README.md

@@ -1,37 +1,200 @@
-# BRK Computer
+# brk_computer
 
-<p align="left">
-  <a href="https://github.com/bitcoinresearchkit/brk">
-    <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/bitcoinresearchkit/brk?style=social">
-  </a>
-  <a href="https://kibo.money">
-    <img alt="kibo.money" src="https://img.shields.io/badge/showcase-kib%C5%8D.money-orange">
-  </a>
-  <a href="https://github.com/bitcoinresearchkit/brk/blob/main/LICENSE.md">
-    <img src="https://img.shields.io/crates/l/brk" alt="License" />
-  </a>
-  <a href="https://crates.io/crates/brk_computer">
-    <img src="https://img.shields.io/crates/v/brk_computer" alt="Version" />
-  </a>
-  <a href="https://docs.rs/brk_computer">
-    <img src="https://img.shields.io/docsrs/brk_computer" alt="Documentation" />
-  </a>
-  <img src="https://img.shields.io/crates/size/brk_computer" alt="Size" />
-  <a href="https://deps.rs/crate/brk_computer">
-    <img src="https://deps.rs/crate/brk_computer/latest/status.svg" alt="Dependency status">
-  </a>
-  <a href="https://discord.gg/HaR3wpH3nr">
-    <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
-  </a>
-  <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
-    <img src="https://img.shields.io/badge/nostr-purple?link=https%3A%2F%2Fprimal.net%2Fp%2Fnprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6" alt="Nostr" />
-  </a>
-  <a href="https://bsky.app/profile/bitcoinresearchkit.org">
-    <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
-  </a>
-  <a href="https://x.com/brkdotorg">
-    <img src="https://img.shields.io/badge/x.com-black" alt="X" />
-  </a>
-</p>
+**Bitcoin analytics engine that transforms indexed blockchain data into comprehensive metrics**
 
-A dataset computer, built on top of `brk_indexer` and `brk_fetcher`. It computes any dataset you can think of and if it doesn't feel free to create an issue.
+`brk_computer` is the computational layer of BRK that processes indexed blockchain data to generate analytics across multiple specialized domains. It provides comprehensive Bitcoin metrics with efficient storage and lazy computation for optimal performance.
+
+## What it provides
+
+- **Comprehensive Analytics**: 9 specialized domains covering all aspects of Bitcoin analysis
+- **Lazy Computation**: On-demand calculation with dependency tracking and caching
+- **Incremental Updates**: Only processes new data since last computation
+- **Memory Efficiency**: ~100MB operation footprint via compressed storage and memory mapping
+- **Multi-timeframe Analysis**: Daily, weekly, monthly, quarterly, yearly perspectives
+
+## Nine Analytics Domains
+
+The computer processes data through a fixed dependency chain:
+
+1. **indexes** - Time-based indexing (date/height mappings, epoch calculations)
+2. **constants** - Baseline values and reference metrics
+3. **blocks** - Block analytics (sizes, intervals, transaction counts, weight)
+4. **mining** - Mining economics (hashrate, difficulty, rewards, epochs)
+5. **fetched** - External price data integration (optional)
+6. **price** - OHLC data across multiple timeframes (optional, requires fetched)
+7. **transactions** - Transaction analysis (fees, sizes, patterns, RBF detection)
+8. **market** - Price correlations and market metrics (optional, requires price)
+9. **stateful** - UTXO tracking and accumulated state computations
+10. **cointime** - Coin age and time-based value analysis
+
+## Key Features
+
+### Computation Strategy
+- **Fixed dependency chain**: Ensures data consistency across all domains
+- **Parallel processing**: Uses Rayon for performance optimization
+- **State management**: Rollback capabilities for error recovery
+- **Incremental updates**: Only computes new data since last run
+
+### Analytics Capabilities
+- **Multi-timeframe analysis**: Daily, weekly, monthly, quarterly, yearly aggregations
+- **Chain-based metrics**: Height, difficulty epoch, halving epoch indexing
+- **Price correlation**: Both dollar and satoshi denominated metrics
+- **DCA analysis**: Dollar Cost Averaging with configurable periods
+- **Supply analysis**: Circulating, realized, unrealized supply metrics
+- **Address cohort tracking**: Analysis across different Bitcoin address types
+- **UTXO cohort analysis**: Realized/unrealized gains tracking
+- **Coin time analysis**: Understanding Bitcoin velocity and dormancy
+
+### Storage Optimization
+- **Compressed vectors**: Efficient disk storage with lazy computation
+- **Memory mapping**: Minimal RAM usage during operation
+- **Version management**: Automatic invalidation on schema changes
+- **Dependency tracking**: Smart recomputation based on data changes
+
+## Usage
+
+### Basic Setup (No Price Data)
+
+```rust
+use brk_computer::Computer;
+use brk_indexer::Indexer;
+use vecdb::Exit;
+
+// Setup without external price data
+let indexer = Indexer::forced_import("./brk_data")?;
+let mut computer = Computer::forced_import("./brk_data", &indexer, None)?;
+
+// Setup exit handler
+let exit = Exit::new();
+exit.set_ctrlc_handler();
+
+// Compute all analytics
+let starting_indexes = indexer.get_starting_indexes();
+computer.compute(&indexer, starting_indexes, &exit)?;
+```
+
+### Advanced Setup (With Price Data)
+
+```rust
+use brk_fetcher::Fetcher;
+
+// Setup with external price data for market analytics
+let fetcher = Some(Fetcher::import(true, None)?);
+let mut computer = Computer::forced_import("./brk_data", &indexer, fetcher)?;
+
+// Compute all analytics including price/market domains
+computer.compute(&indexer, starting_indexes, &exit)?;
+```
+
+### Accessing Computed Data
+
+```rust
+// Access all computed vectors
+let all_vecs = computer.vecs(); // Returns Vec<&dyn AnyCollectableVec>
+
+// Access specific domain data
+let block_metrics = &computer.blocks;
+let mining_data = &computer.mining;
+let transaction_stats = &computer.transactions;
+
+// Access price data (if available)
+if let Some(price_data) = &computer.price {
+    // Use OHLC data
+}
+```
+
+### Incremental Updates
+
+```rust
+// Continuous computation loop
+loop {
+    // Get latest indexes from indexer
+    let current_indexes = indexer.get_current_indexes();
+    
+    // Compute only new data
+    computer.compute(&indexer, current_indexes, &exit)?;
+    
+    // Check for exit signal
+    if exit.is_signaled() {
+        break;
+    }
+    
+    // Wait before next update
+    sleep(Duration::from_secs(60));
+}
+```
+
+## Core Computer Structure
+
+```rust
+pub struct Computer {
+    pub indexes: indexes::Vecs,           // Time indexing
+    pub constants: constants::Vecs,       // Baseline values
+    pub blocks: blocks::Vecs,            // Block analytics
+    pub mining: mining::Vecs,            // Mining economics
+    pub market: market::Vecs,            // Market metrics (optional)
+    pub price: Option<price::Vecs>,      // OHLC price data (optional)
+    pub transactions: transactions::Vecs, // Transaction analysis
+    pub stateful: stateful::Vecs,        // UTXO tracking
+    pub fetched: Option<fetched::Vecs>,  // External data (optional)
+    pub cointime: cointime::Vecs,        // Coin age analysis
+}
+```
+
+## Performance Characteristics
+
+**Benchmarked on MacBook Pro M3 Pro:**
+- **Initial computation**: ~6-7 hours for complete Bitcoin blockchain
+- **Storage efficiency**: All computed datasets total ~40GB
+- **Incremental updates**: 3-5 seconds per new block
+- **Memory footprint**: Peak ~7-8GB during computation, ~100MB during operation
+- **Dependencies**: Price data domains optional (fetched, price, market)
+
+## Domain-Specific Analytics
+
+### Block Analytics
+- Block sizes, weights, transaction counts
+- Block intervals and mining statistics
+- Fee analysis per block
+
+### Mining Economics
+- Hashrate estimation and difficulty tracking
+- Mining reward analysis
+- Epoch-based calculations
+
+### Transaction Analysis
+- Fee rate distributions
+- RBF (Replace-By-Fee) detection
+- Output type analysis
+- Transaction size patterns
+
+### Market Metrics (Optional)
+- Price correlations with on-chain metrics
+- Market cap calculations
+- DCA analysis across timeframes
+
+### Stateful Analysis
+- UTXO set tracking
+- Address cohort analysis
+- Realized/unrealized gains
+- Supply distribution metrics
+
+## Requirements
+
+- **Indexed data**: Requires completed `brk_indexer` output
+- **Storage space**: Additional ~40GB for computed datasets
+- **Memory**: 8GB+ RAM recommended for initial computation
+- **CPU**: Multi-core recommended for parallel processing
+- **Price data**: Optional external price feeds for market analytics
+
+## Dependencies
+
+- `brk_indexer` - Source of indexed blockchain data
+- `brk_fetcher` - External price data (optional)
+- `vecdb` - Vector database with lazy computation
+- `rayon` - Parallel processing framework
+- `brk_structs` - Bitcoin-aware type system
+
+---
+
+*This README was generated by Claude Code*

crates/brk_computer/build.rs

@@ -0,0 +1,8 @@
+fn main() {
+    let profile = std::env::var("PROFILE").unwrap_or_default();
+
+    if profile == "release" {
+        println!("cargo:rustc-flag=-C");
+        println!("cargo:rustc-flag=target-cpu=native");
+    }
+}

crates/brk_computer/examples/computer.rs

@@ -0,0 +1,55 @@
+use std::{
+    path::Path,
+    thread::{self, sleep},
+    time::{Duration, Instant},
+};
+
+use brk_computer::Computer;
+use brk_error::Result;
+use brk_fetcher::Fetcher;
+use brk_indexer::Indexer;
+use brk_parser::Parser;
+use vecdb::Exit;
+
+pub fn main() -> Result<()> {
+    brk_logger::init(Some(Path::new(".log")))?;
+
+    let bitcoin_dir = Path::new(&std::env::var("HOME").unwrap())
+        .join("Library")
+        .join("Application Support")
+        .join("Bitcoin");
+    // let bitcoin_dir = Path::new("/Volumes/WD_BLACK/bitcoin");
+
+    let rpc = Box::leak(Box::new(bitcoincore_rpc::Client::new(
+        "http://localhost:8332",
+        bitcoincore_rpc::Auth::CookieFile(bitcoin_dir.join(".cookie")),
+    )?));
+    let exit = Exit::new();
+    exit.set_ctrlc_handler();
+
+    // Can't increase main thread's stack size, thus we need to use another thread
+    thread::Builder::new()
+        .stack_size(256 * 1024 * 1024)
+        .spawn(move || -> Result<()> {
+            let outputs_dir = Path::new(&std::env::var("HOME").unwrap()).join(".brk");
+            // let outputs_dir = Path::new("../../_outputs");
+
+            let parser = Parser::new(bitcoin_dir.join("blocks"), outputs_dir.to_path_buf(), rpc);
+
+            let mut indexer = Indexer::forced_import(&outputs_dir)?;
+
+            let fetcher = Fetcher::import(true, None)?;
+
+            let mut computer = Computer::forced_import(&outputs_dir, &indexer, Some(fetcher))?;
+
+            loop {
+                let i = Instant::now();
+                let starting_indexes = indexer.index(&parser, rpc, &exit, true)?;
+                computer.compute(&indexer, starting_indexes, &exit)?;
+                dbg!(i.elapsed());
+                sleep(Duration::from_secs(10));
+            }
+        })?
+        .join()
+        .unwrap()
+}

crates/brk_computer/examples/main.rs

@@ -1,54 +0,0 @@
-use std::{path::Path, thread};
-
-use brk_computer::Computer;
-use brk_core::{default_bitcoin_path, default_brk_path};
-use brk_exit::Exit;
-use brk_fetcher::Fetcher;
-use brk_indexer::Indexer;
-use brk_parser::{Parser, rpc};
-use brk_vec::Computation;
-
-pub fn main() -> color_eyre::Result<()> {
-    color_eyre::install()?;
-
-    brk_logger::init(Some(Path::new(".log")));
-
-    let bitcoin_dir = default_bitcoin_path();
-
-    let rpc = Box::leak(Box::new(rpc::Client::new(
-        "http://localhost:8332",
-        rpc::Auth::CookieFile(bitcoin_dir.join(".cookie")),
-    )?));
-    let exit = Exit::new();
-
-    // Can't increase main thread's stack programatically, thus we need to use another thread
-    thread::Builder::new()
-        .stack_size(32 * 1024 * 1024)
-        .spawn(move || -> color_eyre::Result<()> {
-            let parser = Parser::new(bitcoin_dir.join("blocks"), rpc);
-
-            let _outputs_dir = default_brk_path().join("outputs");
-            let outputs_dir = _outputs_dir.as_path();
-            // let outputs_dir = Path::new("../../_outputs");
-
-            let compressed = false;
-
-            let mut indexer = Indexer::new(outputs_dir, compressed, true)?;
-            indexer.import_stores()?;
-            indexer.import_vecs()?;
-
-            let fetcher = Fetcher::import(None)?;
-
-            let mut computer = Computer::new(outputs_dir, Some(fetcher), compressed);
-            computer.import_stores(&indexer)?;
-            computer.import_vecs(&indexer, Computation::Lazy)?;
-
-            let starting_indexes = indexer.index(&parser, rpc, &exit)?;
-
-            computer.compute(&mut indexer, starting_indexes, &exit)?;
-
-            Ok(())
-        })?
-        .join()
-        .unwrap()
-}

crates/brk_computer/examples/price_to_amount.rs

@@ -0,0 +1,15 @@
+use std::path::Path;
+
+use brk_computer::PriceToAmount;
+use brk_error::Result;
+use brk_structs::Height;
+
+pub fn main() -> Result<()> {
+    let path = Path::new(&std::env::var("HOME").unwrap())
+        .join(".brk")
+        .join("computed/stateful/states");
+    let mut price_to_amount = PriceToAmount::create(&path, "addrs_above_1btc_under_10btc");
+    dbg!(price_to_amount.import_at_or_before(Height::new(890000))?);
+    dbg!(price_to_amount);
+    Ok(())
+}

crates/brk_computer/flamegraph.sh

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

crates/brk_computer/samply.sh

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

crates/brk_computer/src/blocks.rs

@@ -1,22 +1,27 @@
-use std::{fs, path::Path};
+use std::path::Path;
 
-use brk_core::{
-    CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, StoredUsize,
-    Timestamp, Weight,
-};
-use brk_exit::Exit;
+use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_parser::bitcoin;
-use brk_vec::{AnyCollectableVec, AnyIterableVec, Compressed, Computation, EagerVec, Version};
+use brk_structs::{
+    CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, Timestamp, Version,
+    Weight,
+};
+use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, PAGE_SIZE, VecIterator};
+
+use crate::grouped::Source;
 
 use super::{
     Indexes,
-    grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, VecBuilderOptions},
     indexes,
 };
 
+const VERSION: Version = Version::ZERO;
+
 #[derive(Clone)]
 pub struct Vecs {
+    db: Database,
+
     pub height_to_interval: EagerVec<Height, Timestamp>,
     pub height_to_vbytes: EagerVec<Height, StoredU64>,
     pub difficultyepoch_to_timestamp: EagerVec<DifficultyEpoch, Timestamp>,
@@ -24,89 +29,90 @@ pub struct Vecs {
     pub timeindexes_to_timestamp: ComputedVecsFromDateIndex<Timestamp>,
     pub indexes_to_block_count: ComputedVecsFromHeight<StoredU32>,
     pub indexes_to_block_interval: ComputedVecsFromHeight<Timestamp>,
-    pub indexes_to_block_size: ComputedVecsFromHeight<StoredUsize>,
+    pub indexes_to_block_size: ComputedVecsFromHeight<StoredU64>,
     pub indexes_to_block_vbytes: ComputedVecsFromHeight<StoredU64>,
     pub indexes_to_block_weight: ComputedVecsFromHeight<Weight>,
 }
 
 impl Vecs {
-    pub fn forced_import(
-        path: &Path,
-        _computation: Computation,
-        compressed: Compressed,
-    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
+    pub fn forced_import(parent: &Path, version: Version, indexes: &indexes::Vecs) -> Result<Self> {
+        let db = Database::open(&parent.join("blocks"))?;
+        db.set_min_len(PAGE_SIZE * 1_000_000)?;
 
         Ok(Self {
-            height_to_interval: EagerVec::forced_import(
-                path,
+            height_to_interval: EagerVec::forced_import_compressed(
+                &db,
                 "interval",
-                Version::ZERO,
-                compressed,
+                version + VERSION + Version::ZERO,
             )?,
             timeindexes_to_timestamp: ComputedVecsFromDateIndex::forced_import(
-                path,
+                &db,
                 "timestamp",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_first(),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_first(),
             )?,
             indexes_to_block_interval: ComputedVecsFromHeight::forced_import(
-                path,
+                &db,
                 "block_interval",
-                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default()
                     .add_percentiles()
                     .add_minmax()
                     .add_average(),
             )?,
             indexes_to_block_count: ComputedVecsFromHeight::forced_import(
-                path,
+                &db,
                 "block_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
             )?,
             indexes_to_block_weight: ComputedVecsFromHeight::forced_import(
-                path,
+                &db,
                 "block_weight",
-                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
             )?,
             indexes_to_block_size: ComputedVecsFromHeight::forced_import(
-                path,
+                &db,
                 "block_size",
-                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
+            )?,
+            height_to_vbytes: EagerVec::forced_import_compressed(
+                &db,
+                "vbytes",
+                version + VERSION + Version::ZERO,
             )?,
-            height_to_vbytes: EagerVec::forced_import(path, "vbytes", Version::ZERO, compressed)?,
             indexes_to_block_vbytes: ComputedVecsFromHeight::forced_import(
-                path,
+                &db,
                 "block_vbytes",
-                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
             )?,
-            difficultyepoch_to_timestamp: EagerVec::forced_import(
-                path,
+            difficultyepoch_to_timestamp: EagerVec::forced_import_compressed(
+                &db,
                 "timestamp",
-                Version::ZERO,
-                compressed,
+                version + VERSION + Version::ZERO,
             )?,
-            halvingepoch_to_timestamp: EagerVec::forced_import(
-                path,
+            halvingepoch_to_timestamp: EagerVec::forced_import_compressed(
+                &db,
                 "timestamp",
-                Version::ZERO,
-                compressed,
+                version + VERSION + Version::ZERO,
             )?,
+
+            db,
         })
     }
 
@@ -116,8 +122,20 @@ impl Vecs {
         indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        self.timeindexes_to_timestamp.compute(
+    ) -> Result<()> {
+        self.compute_(indexer, indexes, starting_indexes, exit)?;
+        self.db.flush_then_punch()?;
+        Ok(())
+    }
+
+    fn compute_(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.timeindexes_to_timestamp.compute_all(
             indexer,
             indexes,
             starting_indexes,
@@ -128,7 +146,8 @@ impl Vecs {
                     &indexes.dateindex_to_date,
                     |(di, d, ..)| (di, Timestamp::from(d)),
                     exit,
-                )
+                )?;
+                Ok(())
             },
         )?;
 
@@ -138,23 +157,20 @@ 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,
-                )
+                )?;
+                Ok(())
             },
         )?;
 
-        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);
@@ -178,19 +194,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,
@@ -207,7 +223,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,

crates/brk_computer/src/cointime.rs

@@ -0,0 +1,719 @@
+use std::path::Path;
+
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF64, Version};
+use vecdb::{AnyCollectableVec, Database, Exit, PAGE_SIZE, VecIterator};
+
+use super::{
+    Indexes,
+    grouped::{
+        ComputedRatioVecsFromDateIndex, ComputedValueVecsFromHeight, ComputedVecsFromHeight,
+        Source, VecBuilderOptions,
+    },
+    indexes, price, stateful, transactions,
+};
+
+const VERSION: Version = Version::ZERO;
+
+#[derive(Clone)]
+pub struct Vecs {
+    db: Database,
+
+    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(
+        parent: &Path,
+        version: Version,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+    ) -> Result<Self> {
+        let db = Database::open(&parent.join("cointime"))?;
+        db.set_min_len(PAGE_SIZE * 1_000_000)?;
+
+        let compute_dollars = price.is_some();
+
+        Ok(Self {
+            indexes_to_coinblocks_created: ComputedVecsFromHeight::forced_import(
+                &db,
+                "coinblocks_created",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
+            )?,
+            indexes_to_coinblocks_stored: ComputedVecsFromHeight::forced_import(
+                &db,
+                "coinblocks_stored",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
+            )?,
+            indexes_to_liveliness: ComputedVecsFromHeight::forced_import(
+                &db,
+                "liveliness",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_vaultedness: ComputedVecsFromHeight::forced_import(
+                &db,
+                "vaultedness",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_activity_to_vaultedness_ratio: ComputedVecsFromHeight::forced_import(
+                &db,
+                "activity_to_vaultedness_ratio",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_supply: ComputedValueVecsFromHeight::forced_import(
+                &db,
+                "vaulted_supply",
+                Source::Compute,
+                version + VERSION + Version::ONE,
+                VecBuilderOptions::default().add_last(),
+                compute_dollars,
+                indexes,
+            )?,
+            indexes_to_active_supply: ComputedValueVecsFromHeight::forced_import(
+                &db,
+                "active_supply",
+                Source::Compute,
+                version + VERSION + Version::ONE,
+                VecBuilderOptions::default().add_last(),
+                compute_dollars,
+                indexes,
+            )?,
+            indexes_to_thermo_cap: ComputedVecsFromHeight::forced_import(
+                &db,
+                "thermo_cap",
+                Source::Compute,
+                version + VERSION + Version::ONE,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_investor_cap: ComputedVecsFromHeight::forced_import(
+                &db,
+                "investor_cap",
+                Source::Compute,
+                version + VERSION + Version::ONE,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_cap: ComputedVecsFromHeight::forced_import(
+                &db,
+                "vaulted_cap",
+                Source::Compute,
+                version + VERSION + Version::ONE,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_active_cap: ComputedVecsFromHeight::forced_import(
+                &db,
+                "active_cap",
+                Source::Compute,
+                version + VERSION + Version::ONE,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_price: ComputedVecsFromHeight::forced_import(
+                &db,
+                "vaulted_price",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_vaulted_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                &db,
+                "vaulted_price",
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                true,
+            )?,
+            indexes_to_active_price: ComputedVecsFromHeight::forced_import(
+                &db,
+                "active_price",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_active_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                &db,
+                "active_price",
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                true,
+            )?,
+            indexes_to_true_market_mean: ComputedVecsFromHeight::forced_import(
+                &db,
+                "true_market_mean",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_true_market_mean_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                &db,
+                "true_market_mean",
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                true,
+            )?,
+            indexes_to_cointime_value_destroyed: ComputedVecsFromHeight::forced_import(
+                &db,
+                "cointime_value_destroyed",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
+            )?,
+            indexes_to_cointime_value_created: ComputedVecsFromHeight::forced_import(
+                &db,
+                "cointime_value_created",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
+            )?,
+            indexes_to_cointime_value_stored: ComputedVecsFromHeight::forced_import(
+                &db,
+                "cointime_value_stored",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_sum().add_cumulative(),
+            )?,
+            indexes_to_cointime_price: ComputedVecsFromHeight::forced_import(
+                &db,
+                "cointime_price",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_cointime_cap: ComputedVecsFromHeight::forced_import(
+                &db,
+                "cointime_cap",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            indexes_to_cointime_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
+                &db,
+                "cointime_price",
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                true,
+            )?,
+
+            db,
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        price: Option<&price::Vecs>,
+        transactions: &transactions::Vecs,
+        stateful: &stateful::Vecs,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.compute_(
+            indexer,
+            indexes,
+            starting_indexes,
+            price,
+            transactions,
+            stateful,
+            exit,
+        )?;
+        self.db.flush_then_punch()?;
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        price: Option<&price::Vecs>,
+        transactions: &transactions::Vecs,
+        stateful: &stateful::Vecs,
+        exit: &Exit,
+    ) -> Result<()> {
+        let circulating_supply = &stateful.utxo_cohorts.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,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        let indexes_to_coinblocks_destroyed =
+            &stateful.utxo_cohorts.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,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        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,
+                )?;
+                Ok(())
+            },
+        )?;
+        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,
+                )?;
+                Ok(())
+            },
+        )?;
+        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,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        self.indexes_to_vaulted_supply.compute_all(
+            indexer,
+            indexes,
+            price,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_multiply(
+                    starting_indexes.height,
+                    circulating_supply,
+                    vaultedness.height.as_ref().unwrap(),
+                    exit,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        self.indexes_to_active_supply.compute_all(
+            indexer,
+            indexes,
+            price,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_multiply(
+                    starting_indexes.height,
+                    circulating_supply,
+                    liveliness.height.as_ref().unwrap(),
+                    exit,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        if let Some(price) = price {
+            let realized_cap = stateful
+                .utxo_cohorts
+                .all
+                .1
+                .height_to_realized_cap
+                .as_ref()
+                .unwrap();
+
+            let realized_price = stateful
+                .utxo_cohorts
+                .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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            self.indexes_to_vaulted_price_ratio.compute_rest(
+                indexer,
+                indexes,
+                price,
+                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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            self.indexes_to_active_price_ratio.compute_rest(
+                indexer,
+                indexes,
+                price,
+                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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            self.indexes_to_true_market_mean_ratio.compute_rest(
+                indexer,
+                indexes,
+                price,
+                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,
+                        &price.chainindexes_to_close.height,
+                        indexes_to_coinblocks_destroyed.height.as_ref().unwrap(),
+                        exit,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            self.indexes_to_cointime_value_created.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        &price.chainindexes_to_close.height,
+                        self.indexes_to_coinblocks_created.height.as_ref().unwrap(),
+                        exit,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            self.indexes_to_cointime_value_stored.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, _, starting_indexes, exit| {
+                    vec.compute_multiply(
+                        starting_indexes.height,
+                        &price.chainindexes_to_close.height,
+                        self.indexes_to_coinblocks_stored.height.as_ref().unwrap(),
+                        exit,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            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,
+                    )?;
+                    Ok(())
+                },
+            )?;
+
+            self.indexes_to_cointime_price_ratio.compute_rest(
+                indexer,
+                indexes,
+                price,
+                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<_>>()
+    }
+}

crates/brk_computer/src/constants.rs

@@ -0,0 +1,250 @@
+use std::path::Path;
+
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{StoredI16, StoredU16, Version};
+use vecdb::{AnyCollectableVec, AnyVec, Database, Exit};
+
+use crate::grouped::Source;
+
+use super::{
+    Indexes,
+    grouped::{ComputedVecsFromHeight, VecBuilderOptions},
+    indexes,
+};
+
+const VERSION: Version = Version::ZERO;
+
+#[derive(Clone)]
+pub struct Vecs {
+    db: Database,
+
+    pub constant_0: ComputedVecsFromHeight<StoredU16>,
+    pub constant_1: ComputedVecsFromHeight<StoredU16>,
+    pub constant_2: ComputedVecsFromHeight<StoredU16>,
+    pub constant_3: ComputedVecsFromHeight<StoredU16>,
+    pub constant_4: ComputedVecsFromHeight<StoredU16>,
+    pub constant_50: ComputedVecsFromHeight<StoredU16>,
+    pub constant_100: ComputedVecsFromHeight<StoredU16>,
+    pub constant_144: ComputedVecsFromHeight<StoredU16>,
+    pub constant_600: ComputedVecsFromHeight<StoredU16>,
+    pub constant_minus_1: ComputedVecsFromHeight<StoredI16>,
+    pub constant_minus_2: ComputedVecsFromHeight<StoredI16>,
+    pub constant_minus_3: ComputedVecsFromHeight<StoredI16>,
+    pub constant_minus_4: ComputedVecsFromHeight<StoredI16>,
+}
+
+impl Vecs {
+    pub fn forced_import(parent: &Path, version: Version, indexes: &indexes::Vecs) -> Result<Self> {
+        let db = Database::open(&parent.join("constants"))?;
+
+        Ok(Self {
+            constant_0: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_0",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_1: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_1",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_2: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_2",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_3: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_3",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_4: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_4",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_50: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_50",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_100: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_100",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_144: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_144",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_600: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_600",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_minus_1: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_minus_1",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_minus_2: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_minus_2",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_minus_3: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_minus_3",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            constant_minus_4: ComputedVecsFromHeight::forced_import(
+                &db,
+                "constant_minus_4",
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+
+            db,
+        })
+    }
+
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.compute_(indexer, indexes, starting_indexes, exit)?;
+        self.db.flush_then_punch()?;
+        Ok(())
+    }
+
+    fn compute_(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        [
+            (&mut self.constant_0, 0),
+            (&mut self.constant_1, 1),
+            (&mut self.constant_2, 2),
+            (&mut self.constant_3, 3),
+            (&mut self.constant_4, 4),
+            (&mut self.constant_50, 50),
+            (&mut self.constant_100, 100),
+            (&mut self.constant_144, 144),
+            (&mut self.constant_600, 600),
+        ]
+        .into_iter()
+        .try_for_each(|(vec, value)| {
+            vec.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, indexes, starting_indexes, exit| {
+                    vec.compute_to(
+                        starting_indexes.height,
+                        indexes.height_to_date.len(),
+                        indexes.height_to_date.version(),
+                        |i| (i, StoredU16::new(value)),
+                        exit,
+                    )?;
+                    Ok(())
+                },
+            )
+        })?;
+
+        [
+            (&mut self.constant_minus_1, -1),
+            (&mut self.constant_minus_2, -2),
+            (&mut self.constant_minus_3, 3),
+            (&mut self.constant_minus_4, 4),
+        ]
+        .into_iter()
+        .try_for_each(|(vec, value)| {
+            vec.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |vec, _, indexes, starting_indexes, exit| {
+                    vec.compute_to(
+                        starting_indexes.height,
+                        indexes.height_to_date.len(),
+                        indexes.height_to_date.version(),
+                        |i| (i, StoredI16::new(value)),
+                        exit,
+                    )?;
+                    Ok(())
+                },
+            )
+        })?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.constant_0.vecs(),
+            self.constant_1.vecs(),
+            self.constant_2.vecs(),
+            self.constant_3.vecs(),
+            self.constant_4.vecs(),
+            self.constant_50.vecs(),
+            self.constant_100.vecs(),
+            self.constant_144.vecs(),
+            self.constant_600.vecs(),
+            self.constant_minus_1.vecs(),
+            self.constant_minus_2.vecs(),
+            self.constant_minus_3.vecs(),
+            self.constant_minus_4.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/fetched.rs

@@ -0,0 +1,139 @@
+use std::path::Path;
+
+use brk_error::Result;
+use brk_fetcher::Fetcher;
+use brk_indexer::Indexer;
+use brk_structs::{DateIndex, Height, OHLCCents, Version};
+use vecdb::{
+    AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec,
+    RawVec, StoredIndex, VecIterator,
+};
+
+use super::{Indexes, indexes};
+
+#[derive(Clone)]
+pub struct Vecs {
+    db: Database,
+    fetcher: Fetcher,
+
+    pub dateindex_to_ohlc_in_cents: RawVec<DateIndex, OHLCCents>,
+    pub height_to_ohlc_in_cents: RawVec<Height, OHLCCents>,
+}
+
+impl Vecs {
+    pub fn forced_import(parent: &Path, fetcher: Fetcher, version: Version) -> Result<Self> {
+        let db = Database::open(&parent.join("fetched"))?;
+
+        Ok(Self {
+            fetcher,
+
+            dateindex_to_ohlc_in_cents: RawVec::forced_import(
+                &db,
+                "ohlc_in_cents",
+                version + Version::ZERO,
+            )?,
+            height_to_ohlc_in_cents: RawVec::forced_import(
+                &db,
+                "ohlc_in_cents",
+                version + Version::ZERO,
+            )?,
+
+            db,
+        })
+    }
+
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.compute_(indexer, indexes, starting_indexes, exit)?;
+        self.db.flush_then_punch()?;
+        Ok(())
+    }
+
+    fn compute_(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        let height_to_timestamp = &indexer.vecs.height_to_timestamp;
+        let index = starting_indexes
+            .height
+            .min(Height::from(self.height_to_ohlc_in_cents.len()));
+        height_to_timestamp
+            .iter_at(index)
+            .try_for_each(|(i, v)| -> Result<()> {
+                let v = v.into_owned();
+                self.height_to_ohlc_in_cents.forced_push_at(
+                    i,
+                    self.fetcher
+                        .get_height(
+                            i,
+                            v,
+                            i.decremented().map(|prev_i| {
+                                height_to_timestamp.into_iter().unwrap_get_inner(prev_i)
+                            }),
+                        )
+                        .unwrap(),
+                    exit,
+                )?;
+                Ok(())
+            })?;
+        self.height_to_ohlc_in_cents.safe_flush(exit)?;
+
+        let index = starting_indexes
+            .dateindex
+            .min(DateIndex::from(self.dateindex_to_ohlc_in_cents.len()));
+        let mut prev = None;
+        indexes
+            .dateindex_to_date
+            .iter_at(index)
+            .try_for_each(|(i, v)| -> Result<()> {
+                let d = v.into_owned();
+                if prev.is_none() {
+                    let i = i.unwrap_to_usize();
+                    prev.replace(if i > 0 {
+                        self.dateindex_to_ohlc_in_cents
+                            .into_iter()
+                            .unwrap_get_inner_(i - 1)
+                    } else {
+                        OHLCCents::default()
+                    });
+                }
+
+                let ohlc = if i.unwrap_to_usize() + 100 >= self.dateindex_to_ohlc_in_cents.len()
+                    && let Ok(mut ohlc) = self.fetcher.get_date(d)
+                {
+                    let prev_open = *prev.as_ref().unwrap().close;
+                    *ohlc.open = prev_open;
+                    *ohlc.high = (*ohlc.high).max(prev_open);
+                    *ohlc.low = (*ohlc.low).min(prev_open);
+                    ohlc
+                } else {
+                    prev.clone().unwrap()
+                };
+
+                prev.replace(ohlc.clone());
+
+                self.dateindex_to_ohlc_in_cents
+                    .forced_push_at(i, ohlc, exit)?;
+
+                Ok(())
+            })?;
+        self.dateindex_to_ohlc_in_cents.safe_flush(exit)?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        vec![
+            &self.dateindex_to_ohlc_in_cents as &dyn AnyCollectableVec,
+            &self.height_to_ohlc_in_cents,
+        ]
+    }
+}

crates/brk_computer/src/grouped/builder_computed.rs

@@ -0,0 +1,473 @@
+use brk_error::Result;
+
+use brk_structs::Version;
+use vecdb::{
+    AnyBoxedIterableVec, AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Computation,
+    ComputedVec, ComputedVecFrom2, Database, Exit, Format, FromCoarserIndex, StoredIndex,
+};
+
+use crate::grouped::{EagerVecBuilder, VecBuilderOptions};
+
+use super::ComputedType;
+
+#[allow(clippy::type_complexity)]
+#[derive(Clone)]
+pub struct ComputedVecBuilder<I, T, S1I, S2T>
+where
+    I: StoredIndex,
+    T: ComputedType,
+    S2T: ComputedType,
+{
+    pub first: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub average: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub sum: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub max: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub min: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub last: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub cumulative: Option<Box<ComputedVecFrom2<I, T, S1I, T, I, S2T>>>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<I, T, S1I, S2T> ComputedVecBuilder<I, T, S1I, S2T>
+where
+    I: StoredIndex,
+    T: ComputedType + 'static,
+    S1I: StoredIndex + 'static + FromCoarserIndex<I>,
+    S2T: ComputedType,
+{
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        format: Format,
+        computation: Computation,
+        source: Option<AnyBoxedIterableVec<S1I, T>>,
+        source_extra: &EagerVecBuilder<S1I, T>,
+        len_source: AnyBoxedIterableVec<I, S2T>,
+        options: ComputedVecBuilderOptions,
+    ) -> Result<Self> {
+        let only_one_active = options.is_only_one_active();
+
+        let suffix = |s: &str| format!("{name}_{s}");
+
+        let maybe_suffix = |s: &str| {
+            if only_one_active {
+                name.to_string()
+            } else {
+                suffix(s)
+            }
+        };
+
+        Ok(Self {
+            first: options.first.then(|| {
+                Box::new(
+                    ComputedVec::forced_import_or_init_from_2(
+                        computation,
+                        db,
+                        &maybe_suffix("first"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                        source_extra
+                            .first
+                            .as_ref()
+                            .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                        len_source.clone(),
+                        |i: I, source, len_source| {
+                            if i.unwrap_to_usize() >= len_source.len() {
+                                return None;
+                            }
+                            source
+                                .next_at(S1I::min_from(i))
+                                .map(|(_, cow)| cow.into_owned())
+                        },
+                    )
+                    .unwrap(),
+                )
+            }),
+            last: options.last.then(|| {
+                Box::new(
+                    ComputedVec::forced_import_or_init_from_2(
+                        computation,
+                        db,
+                        name,
+                        version + VERSION + Version::ZERO,
+                        format,
+                        source_extra.last.as_ref().map_or_else(
+                            || {
+                                source
+                                    .as_ref()
+                                    .unwrap_or_else(|| {
+                                        dbg!(db, name, I::to_string());
+                                        panic!()
+                                    })
+                                    .clone()
+                            },
+                            |v| v.clone(),
+                        ),
+                        len_source.clone(),
+                        |i: I, source, len_source| {
+                            if i.unwrap_to_usize() >= len_source.len() {
+                                return None;
+                            }
+                            source
+                                .next_at(S1I::max_from(i, source.len()))
+                                .map(|(_, cow)| cow.into_owned())
+                        },
+                    )
+                    .unwrap(),
+                )
+            }),
+            min: options.min.then(|| {
+                Box::new(
+                    ComputedVec::forced_import_or_init_from_2(
+                        computation,
+                        db,
+                        &maybe_suffix("min"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                        source_extra
+                            .min
+                            .as_ref()
+                            .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                        len_source.clone(),
+                        |i: I, source, len_source| {
+                            if i.unwrap_to_usize() >= len_source.len() {
+                                return None;
+                            }
+                            S1I::inclusive_range_from(i, source.len())
+                                .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                                .min()
+                        },
+                    )
+                    .unwrap(),
+                )
+            }),
+            max: options.max.then(|| {
+                Box::new(
+                    ComputedVec::forced_import_or_init_from_2(
+                        computation,
+                        db,
+                        &maybe_suffix("max"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                        source_extra
+                            .max
+                            .as_ref()
+                            .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                        len_source.clone(),
+                        |i: I, source, len_source| {
+                            if i.unwrap_to_usize() >= len_source.len() {
+                                return None;
+                            }
+                            S1I::inclusive_range_from(i, source.len())
+                                .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                                .max()
+                        },
+                    )
+                    .unwrap(),
+                )
+            }),
+            average: options.average.then(|| {
+                Box::new(
+                    ComputedVec::forced_import_or_init_from_2(
+                        computation,
+                        db,
+                        &maybe_suffix("average"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                        source_extra
+                            .average
+                            .as_ref()
+                            .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                        len_source.clone(),
+                        |i: I, source, len_source| {
+                            if i.unwrap_to_usize() >= len_source.len() {
+                                return None;
+                            }
+                            let vec = S1I::inclusive_range_from(i, source.len())
+                                .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                                .collect::<Vec<_>>();
+                            if vec.is_empty() {
+                                return None;
+                            }
+                            let mut sum = T::from(0);
+                            let len = vec.len();
+                            vec.into_iter().for_each(|v| sum += v);
+                            Some(sum / len)
+                        },
+                    )
+                    .unwrap(),
+                )
+            }),
+            sum: options.sum.then(|| {
+                Box::new(
+                    ComputedVec::forced_import_or_init_from_2(
+                        computation,
+                        db,
+                        &(if !options.last && !options.average && !options.min && !options.max {
+                            name.to_string()
+                        } else {
+                            maybe_suffix("sum")
+                        }),
+                        version + VERSION + Version::ZERO,
+                        format,
+                        source_extra
+                            .sum
+                            .as_ref()
+                            .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                        len_source.clone(),
+                        |i: I, source, len_source| {
+                            if i.unwrap_to_usize() >= len_source.len() {
+                                return None;
+                            }
+                            let vec = S1I::inclusive_range_from(i, source.len())
+                                .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                                .collect::<Vec<_>>();
+                            if vec.is_empty() {
+                                return None;
+                            }
+                            let mut sum = T::from(0);
+                            vec.into_iter().for_each(|v| sum += v);
+                            Some(sum)
+                        },
+                    )
+                    .unwrap(),
+                )
+            }),
+            cumulative: options.cumulative.then(|| {
+                Box::new(
+                    ComputedVec::forced_import_or_init_from_2(
+                        computation,
+                        db,
+                        &suffix("cumulative"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                        source_extra.cumulative.as_ref().unwrap().boxed_clone(),
+                        len_source.clone(),
+                        |i: I, source, len_source| {
+                            if i.unwrap_to_usize() >= len_source.len() {
+                                return None;
+                            }
+                            source
+                                .next_at(S1I::max_from(i, source.len()))
+                                .map(|(_, cow)| cow.into_owned())
+                        },
+                    )
+                    .unwrap(),
+                )
+            }),
+        })
+    }
+
+    pub fn compute_if_necessary<T2>(
+        &mut self,
+        max_from: I,
+        len_source: &impl AnyIterableVec<I, T2>,
+        exit: &Exit,
+    ) -> Result<()> {
+        if let Some(first) = self.first.as_mut() {
+            first.compute_if_necessary(max_from, len_source, exit)?;
+        }
+        if let Some(last) = self.last.as_mut() {
+            last.compute_if_necessary(max_from, len_source, exit)?;
+        }
+        if let Some(min) = self.min.as_mut() {
+            min.compute_if_necessary(max_from, len_source, exit)?;
+        }
+        if let Some(max) = self.max.as_mut() {
+            max.compute_if_necessary(max_from, len_source, exit)?;
+        }
+        if let Some(average) = self.average.as_mut() {
+            average.compute_if_necessary(max_from, len_source, exit)?;
+        }
+        if let Some(sum) = self.sum.as_mut() {
+            sum.compute_if_necessary(max_from, len_source, exit)?;
+        }
+        if let Some(cumulative) = self.cumulative.as_mut() {
+            cumulative.compute_if_necessary(max_from, len_source, exit)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn starting_index(&self, max_from: I) -> I {
+        max_from.min(I::from(
+            self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
+        ))
+    }
+
+    pub fn unwrap_first(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
+        self.first.as_ref().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_average(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
+        self.average.as_ref().unwrap()
+    }
+    pub fn unwrap_sum(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
+        self.sum.as_ref().unwrap()
+    }
+    pub fn unwrap_max(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
+        self.max.as_ref().unwrap()
+    }
+    pub fn unwrap_min(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
+        self.min.as_ref().unwrap()
+    }
+    pub fn unwrap_last(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
+        self.last.as_ref().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_cumulative(&self) -> &ComputedVecFrom2<I, T, S1I, T, I, S2T> {
+        self.cumulative.as_ref().unwrap()
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        let mut v: Vec<&dyn AnyCollectableVec> = vec![];
+
+        if let Some(first) = self.first.as_ref() {
+            v.push(first.as_ref());
+        }
+        if let Some(last) = self.last.as_ref() {
+            v.push(last.as_ref());
+        }
+        if let Some(min) = self.min.as_ref() {
+            v.push(min.as_ref());
+        }
+        if let Some(max) = self.max.as_ref() {
+            v.push(max.as_ref());
+        }
+        if let Some(average) = self.average.as_ref() {
+            v.push(average.as_ref());
+        }
+        if let Some(sum) = self.sum.as_ref() {
+            v.push(sum.as_ref());
+        }
+        if let Some(cumulative) = self.cumulative.as_ref() {
+            v.push(cumulative.as_ref());
+        }
+
+        v
+    }
+}
+
+#[derive(Default, Clone, Copy)]
+pub struct ComputedVecBuilderOptions {
+    average: bool,
+    sum: bool,
+    max: bool,
+    min: bool,
+    first: bool,
+    last: bool,
+    cumulative: bool,
+}
+
+impl From<VecBuilderOptions> for ComputedVecBuilderOptions {
+    fn from(value: VecBuilderOptions) -> Self {
+        Self {
+            average: value.average(),
+            sum: value.sum(),
+            max: value.max(),
+            min: value.min(),
+            first: value.first(),
+            last: value.last(),
+            cumulative: value.cumulative(),
+        }
+    }
+}
+
+impl ComputedVecBuilderOptions {
+    pub fn add_first(mut self) -> Self {
+        self.first = true;
+        self
+    }
+
+    pub fn add_last(mut self) -> Self {
+        self.last = true;
+        self
+    }
+
+    pub fn add_min(mut self) -> Self {
+        self.min = true;
+        self
+    }
+
+    pub fn add_max(mut self) -> Self {
+        self.max = true;
+        self
+    }
+
+    pub fn add_average(mut self) -> Self {
+        self.average = true;
+        self
+    }
+
+    pub fn add_sum(mut self) -> Self {
+        self.sum = true;
+        self
+    }
+
+    pub fn add_cumulative(mut self) -> Self {
+        self.cumulative = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_min(mut self) -> Self {
+        self.min = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_max(mut self) -> Self {
+        self.max = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_average(mut self) -> Self {
+        self.average = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_sum(mut self) -> Self {
+        self.sum = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_cumulative(mut self) -> Self {
+        self.cumulative = false;
+        self
+    }
+
+    pub fn add_minmax(mut self) -> Self {
+        self.min = true;
+        self.max = true;
+        self
+    }
+
+    pub fn is_only_one_active(&self) -> bool {
+        [
+            self.average,
+            self.sum,
+            self.max,
+            self.min,
+            self.first,
+            self.last,
+            self.cumulative,
+        ]
+        .iter()
+        .filter(|b| **b)
+        .count()
+            == 1
+    }
+
+    pub fn copy_self_extra(&self) -> Self {
+        Self {
+            cumulative: self.cumulative,
+            ..Self::default()
+        }
+    }
+}

crates/brk_computer/src/grouped/builder_eager.rs

@@ -1,19 +1,16 @@
-use std::path::Path;
-
-use brk_core::{CheckedSub, StoredUsize};
-use brk_exit::Exit;
-use brk_vec::{
-    AnyCollectableVec, AnyIterableVec, Compressed, EagerVec, Result, StoredIndex, StoredType,
-    Version,
+use brk_error::{Error, Result};
+use brk_structs::{CheckedSub, StoredU64, Version};
+use vecdb::{
+    AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
+    GenericStoredVec, StoredIndex, StoredRaw,
 };
-use color_eyre::eyre::ContextCompat;
 
 use crate::utils::get_percentile;
 
 use super::ComputedType;
 
 #[derive(Clone, Debug)]
-pub struct ComputedVecBuilder<I, T>
+pub struct EagerVecBuilder<I, T>
 where
     I: StoredIndex,
     T: ComputedType,
@@ -29,35 +26,34 @@ where
     pub _10p: Option<Box<EagerVec<I, T>>>,
     pub min: Option<Box<EagerVec<I, T>>>,
     pub last: Option<Box<EagerVec<I, T>>>,
-    pub total: Option<Box<EagerVec<I, T>>>,
+    pub cumulative: Option<Box<EagerVec<I, T>>>,
 }
 
 const VERSION: Version = Version::ZERO;
 
-impl<I, T> ComputedVecBuilder<I, T>
+impl<I, T> EagerVecBuilder<I, T>
 where
     I: StoredIndex,
     T: ComputedType,
 {
-    pub fn forced_import(
-        path: &Path,
+    pub fn forced_import_compressed(
+        db: &Database,
         name: &str,
         version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
+        options: VecBuilderOptions,
+    ) -> Result<Self> {
+        Self::forced_import(db, name, version, Format::Compressed, options)
+    }
+
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        format: Format,
+        options: VecBuilderOptions,
+    ) -> 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| {
@@ -68,33 +64,30 @@ where
             }
         };
 
-        let version = VERSION + version;
-
         let s = Self {
             first: options.first.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
-                        &maybe_prefix("first"),
-                        version + Version::ZERO,
-                        compressed,
+                        db,
+                        &maybe_suffix("first"),
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
             }),
             last: options.last.then(|| {
                 Box::new(
-                    EagerVec::forced_import(path, name, version + Version::ZERO, compressed)
-                        .unwrap(),
+                    EagerVec::forced_import(db, name, version + Version::ZERO, format).unwrap(),
                 )
             }),
             min: options.min.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("min"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -102,10 +95,10 @@ where
             max: options.max.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("max"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -113,10 +106,10 @@ where
             median: options.median.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("median"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -124,10 +117,10 @@ where
             average: options.average.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("average"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -135,21 +128,25 @@ where
             sum: options.sum.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
-                        &maybe_suffix("sum"),
-                        version + Version::ZERO,
-                        compressed,
+                        db,
+                        &(if !options.last && !options.average && !options.min && !options.max {
+                            name.to_string()
+                        } else {
+                            maybe_suffix("sum")
+                        }),
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
             }),
-            total: options.total.then(|| {
+            cumulative: options.cumulative.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
-                        &prefix("total"),
-                        version + Version::ZERO,
-                        compressed,
+                        db,
+                        &suffix("cumulative"),
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -157,10 +154,10 @@ where
             _90p: options._90p.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("90p"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -168,10 +165,10 @@ where
             _75p: options._75p.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("75p"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -179,10 +176,10 @@ where
             _25p: options._25p.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("25p"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -190,10 +187,10 @@ where
             _10p: options._10p.then(|| {
                 Box::new(
                     EagerVec::forced_import(
-                        path,
+                        db,
                         &maybe_suffix("10p"),
-                        version + Version::ZERO,
-                        compressed,
+                        version + VERSION + Version::ZERO,
+                        format,
                     )
                     .unwrap(),
                 )
@@ -209,20 +206,23 @@ where
         source: &impl AnyIterableVec<I, T>,
         exit: &Exit,
     ) -> Result<()> {
-        if self.total.is_none() {
+        if self.cumulative.is_none() {
             return Ok(());
         };
 
+        self.validate_computed_version_or_reset(source.version())?;
+
         let index = self.starting_index(max_from);
 
-        let total_vec = self.total.as_mut().unwrap();
+        let cumulative_vec = self.cumulative.as_mut().unwrap();
 
-        let mut total = index.decremented().map_or(T::from(0_usize), |index| {
-            total_vec.iter().unwrap_get_inner(index)
+        let mut cumulative = index.decremented().map_or(T::from(0_usize), |index| {
+            cumulative_vec.iter().unwrap_get_inner(index)
         });
         source.iter_at(index).try_for_each(|(i, v)| -> Result<()> {
-            total = total.clone() + v.into_inner();
-            total_vec.forced_push_at(i, total.clone(), exit)
+            cumulative += v.into_owned();
+            cumulative_vec.forced_push_at(i, cumulative, exit)?;
+            Ok(())
         })?;
 
         self.safe_flush(exit)?;
@@ -235,13 +235,13 @@ where
         max_from: I,
         source: &impl AnyIterableVec<I2, T>,
         first_indexes: &impl AnyIterableVec<I, I2>,
-        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
+        count_indexes: &impl AnyIterableVec<I, StoredU64>,
         exit: &Exit,
     ) -> Result<()>
     where
-        I2: StoredIndex + StoredType + CheckedSub<I2>,
+        I2: StoredIndex + StoredRaw + CheckedSub<I2>,
     {
-        self.validate_computed_version_or_reset_file(
+        self.validate_computed_version_or_reset(
             source.version() + first_indexes.version() + count_indexes.version(),
         )?;
 
@@ -250,20 +250,20 @@ where
         let mut count_indexes_iter = count_indexes.iter();
         let mut source_iter = source.iter();
 
-        let total_vec = self.total.as_mut();
+        let cumulative_vec = self.cumulative.as_mut();
 
-        let mut total = total_vec.map(|total_vec| {
+        let mut cumulative = cumulative_vec.map(|cumulative_vec| {
             index.decremented().map_or(T::from(0_usize), |index| {
-                total_vec.iter().unwrap_get_inner(index)
+                cumulative_vec.iter().unwrap_get_inner(index)
             })
         });
 
         first_indexes
             .iter_at(index)
-            .try_for_each(|(i, first_index)| -> Result<()> {
-                let first_index = first_index.into_inner();
+            .try_for_each(|(index, first_index)| -> Result<()> {
+                let first_index = first_index.into_owned();
 
-                let count_index = count_indexes_iter.unwrap_get_inner(i);
+                let count_index = count_indexes_iter.unwrap_get_inner(index);
 
                 if let Some(first) = self.first.as_mut() {
                     let f = source_iter
@@ -273,7 +273,7 @@ where
                 }
 
                 if let Some(last) = self.last.as_mut() {
-                    let count_index = *count_index;
+                    let count_index = *count_index as usize;
                     if count_index == 0 {
                         panic!("should compute last if count can be 0")
                     }
@@ -284,12 +284,13 @@ where
                     //     dbg!(first_index, count_index, last_index);
                     // })
                     // .unwrap()
-                    // .into_inner();
+                    // .into_owned();
                     last.forced_push_at(index, v, exit)?;
                 }
 
-                let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
-                let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
+                let needs_sum_or_cumulative = self.sum.is_some() || self.cumulative.is_some();
+                let needs_average_sum_or_cumulative =
+                    needs_sum_or_cumulative || self.average.is_some();
                 let needs_sorted = self.max.is_some()
                     || self._90p.is_some()
                     || self._75p.is_some()
@@ -297,13 +298,13 @@ where
                     || self._25p.is_some()
                     || self._10p.is_some()
                     || self.min.is_some();
-                let needs_values = needs_sorted || needs_average_sum_or_total;
+                let needs_values = needs_sorted || needs_average_sum_or_cumulative;
 
                 if needs_values {
                     source_iter.set(first_index);
                     let mut values = (&mut source_iter)
-                        .take(*count_index)
-                        .map(|(_, v)| v.into_inner())
+                        .take(*count_index as usize)
+                        .map(|(_, v)| v.into_owned())
                         .collect::<Vec<_>>();
 
                     if needs_sorted {
@@ -311,14 +312,14 @@ where
 
                         if let Some(max) = self.max.as_mut() {
                             max.forced_push_at(
-                                i,
-                                values
+                                index,
+                                *values
                                     .last()
-                                    .context("expect some")
+                                    .ok_or(Error::Str("expect some"))
                                     .inspect_err(|_| {
                                         dbg!(
                                             &values,
-                                            max.path(),
+                                            max.name(),
                                             first_indexes.name(),
                                             first_index,
                                             count_indexes.name(),
@@ -327,55 +328,54 @@ where
                                             source.name()
                                         );
                                     })
-                                    .unwrap()
-                                    .clone(),
+                                    .unwrap(),
                                 exit,
                             )?;
                         }
 
                         if let Some(_90p) = self._90p.as_mut() {
-                            _90p.forced_push_at(i, get_percentile(&values, 0.90), exit)?;
+                            _90p.forced_push_at(index, get_percentile(&values, 0.90), exit)?;
                         }
 
                         if let Some(_75p) = self._75p.as_mut() {
-                            _75p.forced_push_at(i, get_percentile(&values, 0.75), exit)?;
+                            _75p.forced_push_at(index, get_percentile(&values, 0.75), exit)?;
                         }
 
                         if let Some(median) = self.median.as_mut() {
-                            median.forced_push_at(i, get_percentile(&values, 0.50), exit)?;
+                            median.forced_push_at(index, get_percentile(&values, 0.50), exit)?;
                         }
 
                         if let Some(_25p) = self._25p.as_mut() {
-                            _25p.forced_push_at(i, get_percentile(&values, 0.25), exit)?;
+                            _25p.forced_push_at(index, get_percentile(&values, 0.25), exit)?;
                         }
 
                         if let Some(_10p) = self._10p.as_mut() {
-                            _10p.forced_push_at(i, get_percentile(&values, 0.10), exit)?;
+                            _10p.forced_push_at(index, get_percentile(&values, 0.10), exit)?;
                         }
 
                         if let Some(min) = self.min.as_mut() {
-                            min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
+                            min.forced_push_at(index, *values.first().unwrap(), exit)?;
                         }
                     }
 
-                    if needs_average_sum_or_total {
+                    if needs_average_sum_or_cumulative {
                         let len = values.len();
                         let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
 
                         if let Some(average) = self.average.as_mut() {
-                            let avg = sum.clone() / len;
-                            average.forced_push_at(i, avg, exit)?;
+                            let avg = sum / len;
+                            average.forced_push_at(index, avg, exit)?;
                         }
 
-                        if needs_sum_or_total {
+                        if needs_sum_or_cumulative {
                             if let Some(sum_vec) = self.sum.as_mut() {
-                                sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                                sum_vec.forced_push_at(index, sum, exit)?;
                             }
 
-                            if let Some(total_vec) = self.total.as_mut() {
-                                let t = total.as_ref().unwrap().clone() + sum;
-                                total.replace(t.clone());
-                                total_vec.forced_push_at(i, t, exit)?;
+                            if let Some(cumulative_vec) = self.cumulative.as_mut() {
+                                let t = cumulative.unwrap() + sum;
+                                cumulative.replace(t);
+                                cumulative_vec.forced_push_at(index, t, exit)?;
                             }
                         }
                     }
@@ -393,13 +393,13 @@ where
     pub fn from_aligned<I2>(
         &mut self,
         max_from: I,
-        source: &ComputedVecBuilder<I2, T>,
+        source: &EagerVecBuilder<I2, T>,
         first_indexes: &impl AnyIterableVec<I, I2>,
-        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
+        count_indexes: &impl AnyIterableVec<I, StoredU64>,
         exit: &Exit,
     ) -> Result<()>
     where
-        I2: StoredIndex + StoredType + CheckedSub<I2>,
+        I2: StoredIndex + StoredRaw + CheckedSub<I2>,
     {
         if self._90p.is_some()
             || self._75p.is_some()
@@ -410,7 +410,7 @@ where
             panic!("unsupported");
         }
 
-        self.validate_computed_version_or_reset_file(
+        self.validate_computed_version_or_reset(
             VERSION + first_indexes.version() + count_indexes.version(),
         )?;
 
@@ -425,18 +425,18 @@ where
         let mut source_average_iter = source.average.as_ref().map(|f| f.iter());
         let mut source_sum_iter = source.sum.as_ref().map(|f| f.iter());
 
-        let mut total = self.total.as_mut().map(|total_vec| {
+        let mut cumulative = self.cumulative.as_mut().map(|cumulative_vec| {
             index.decremented().map_or(T::from(0_usize), |index| {
-                total_vec.iter().unwrap_get_inner(index)
+                cumulative_vec.iter().unwrap_get_inner(index)
             })
         });
 
         first_indexes
             .iter_at(index)
-            .try_for_each(|(i, first_index, ..)| -> Result<()> {
-                let first_index = first_index.into_inner();
+            .try_for_each(|(index, first_index, ..)| -> Result<()> {
+                let first_index = first_index.into_owned();
 
-                let count_index = count_indexes_iter.unwrap_get_inner(i);
+                let count_index = count_indexes_iter.unwrap_get_inner(index);
 
                 if let Some(first) = self.first.as_mut() {
                     let v = source_first_iter
@@ -447,7 +447,7 @@ where
                 }
 
                 if let Some(last) = self.last.as_mut() {
-                    let count_index = *count_index;
+                    let count_index = *count_index as usize;
                     if count_index == 0 {
                         panic!("should compute last if count can be 0")
                     }
@@ -459,10 +459,11 @@ where
                     last.forced_push_at(index, v, exit)?;
                 }
 
-                let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
-                let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
+                let needs_sum_or_cumulative = self.sum.is_some() || self.cumulative.is_some();
+                let needs_average_sum_or_cumulative =
+                    needs_sum_or_cumulative || self.average.is_some();
                 let needs_sorted = self.max.is_some() || self.min.is_some();
-                let needs_values = needs_sorted || needs_average_sum_or_total;
+                let needs_values = needs_sorted || needs_average_sum_or_cumulative;
 
                 if needs_values {
                     if needs_sorted {
@@ -470,60 +471,60 @@ where
                             let source_max_iter = source_max_iter.as_mut().unwrap();
                             source_max_iter.set(first_index);
                             let mut values = source_max_iter
-                                .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .take(*count_index as usize)
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
                             values.sort_unstable();
-                            max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
+                            max.forced_push_at(index, *values.last().unwrap(), exit)?;
                         }
 
                         if let Some(min) = self.min.as_mut() {
                             let source_min_iter = source_min_iter.as_mut().unwrap();
                             source_min_iter.set(first_index);
                             let mut values = source_min_iter
-                                .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .take(*count_index as usize)
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
                             values.sort_unstable();
-                            min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
+                            min.forced_push_at(index, *values.first().unwrap(), exit)?;
                         }
                     }
 
-                    if needs_average_sum_or_total {
+                    if needs_average_sum_or_cumulative {
                         if let Some(average) = self.average.as_mut() {
                             let source_average_iter = source_average_iter.as_mut().unwrap();
                             source_average_iter.set(first_index);
                             let values = source_average_iter
-                                .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .take(*count_index as usize)
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
 
                             let len = values.len();
-                            let total = values.into_iter().fold(T::from(0), |a, b| a + b);
-                            // TODO: Multiply by count then divide by total
+                            let cumulative = values.into_iter().fold(T::from(0), |a, b| a + b);
+                            // TODO: Multiply by count then divide by cumulative
                             // Right now it's not 100% accurate as there could be more or less elements in the lower timeframe (28 days vs 31 days in a month for example)
-                            let avg = total / len;
-                            average.forced_push_at(i, avg, exit)?;
+                            let avg = cumulative / len;
+                            average.forced_push_at(index, avg, exit)?;
                         }
 
-                        if needs_sum_or_total {
+                        if needs_sum_or_cumulative {
                             let source_sum_iter = source_sum_iter.as_mut().unwrap();
                             source_sum_iter.set(first_index);
                             let values = source_sum_iter
-                                .take(*count_index)
-                                .map(|(_, v)| v.into_inner())
+                                .take(*count_index as usize)
+                                .map(|(_, v)| v.into_owned())
                                 .collect::<Vec<_>>();
 
                             let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
 
                             if let Some(sum_vec) = self.sum.as_mut() {
-                                sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                                sum_vec.forced_push_at(index, sum, exit)?;
                             }
 
-                            if let Some(total_vec) = self.total.as_mut() {
-                                let t = total.as_ref().unwrap().clone() + sum;
-                                total.replace(t.clone());
-                                total_vec.forced_push_at(i, t, exit)?;
+                            if let Some(cumulative_vec) = self.cumulative.as_mut() {
+                                let t = cumulative.unwrap() + sum;
+                                cumulative.replace(t);
+                                cumulative_vec.forced_push_at(index, t, exit)?;
                             }
                         }
                     }
@@ -583,8 +584,8 @@ where
         self.last.as_ref().unwrap()
     }
     #[allow(unused)]
-    pub fn unwrap_total(&self) -> &EagerVec<I, T> {
-        self.total.as_ref().unwrap()
+    pub fn unwrap_cumulative(&self) -> &EagerVec<I, T> {
+        self.cumulative.as_ref().unwrap()
     }
 
     pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
@@ -611,8 +612,8 @@ where
         if let Some(sum) = self.sum.as_ref() {
             v.push(sum.as_ref());
         }
-        if let Some(total) = self.total.as_ref() {
-            v.push(total.as_ref());
+        if let Some(cumulative) = self.cumulative.as_ref() {
+            v.push(cumulative.as_ref());
         }
         if let Some(_90p) = self._90p.as_ref() {
             v.push(_90p.as_ref());
@@ -652,8 +653,8 @@ where
         if let Some(sum) = self.sum.as_mut() {
             sum.safe_flush(exit)?;
         }
-        if let Some(total) = self.total.as_mut() {
-            total.safe_flush(exit)?;
+        if let Some(cumulative) = self.cumulative.as_mut() {
+            cumulative.safe_flush(exit)?;
         }
         if let Some(_90p) = self._90p.as_mut() {
             _90p.safe_flush(exit)?;
@@ -671,42 +672,42 @@ where
         Ok(())
     }
 
-    pub fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
+    pub fn validate_computed_version_or_reset(&mut self, version: Version) -> Result<()> {
         if let Some(first) = self.first.as_mut() {
-            first.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            first.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(last) = self.last.as_mut() {
-            last.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            last.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(min) = self.min.as_mut() {
-            min.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            min.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(max) = self.max.as_mut() {
-            max.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            max.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(median) = self.median.as_mut() {
-            median.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            median.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(average) = self.average.as_mut() {
-            average.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            average.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(sum) = self.sum.as_mut() {
-            sum.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            sum.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
-        if let Some(total) = self.total.as_mut() {
-            total.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        if let Some(cumulative) = self.cumulative.as_mut() {
+            cumulative.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(_90p) = self._90p.as_mut() {
-            _90p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            _90p.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(_75p) = self._75p.as_mut() {
-            _75p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            _75p.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(_25p) = self._25p.as_mut() {
-            _25p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            _25p.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
         if let Some(_10p) = self._10p.as_mut() {
-            _10p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+            _10p.validate_computed_version_or_reset(Version::ZERO + version)?;
         }
 
         Ok(())
@@ -714,7 +715,7 @@ where
 }
 
 #[derive(Default, Clone, Copy)]
-pub struct StorableVecGeneatorOptions {
+pub struct VecBuilderOptions {
     average: bool,
     sum: bool,
     max: bool,
@@ -726,10 +727,58 @@ pub struct StorableVecGeneatorOptions {
     min: bool,
     first: bool,
     last: bool,
-    total: bool,
+    cumulative: bool,
 }
 
-impl StorableVecGeneatorOptions {
+impl VecBuilderOptions {
+    pub fn average(&self) -> bool {
+        self.average
+    }
+
+    pub fn sum(&self) -> bool {
+        self.sum
+    }
+
+    pub fn max(&self) -> bool {
+        self.max
+    }
+
+    pub fn _90p(&self) -> bool {
+        self._90p
+    }
+
+    pub fn _75p(&self) -> bool {
+        self._75p
+    }
+
+    pub fn median(&self) -> bool {
+        self.median
+    }
+
+    pub fn _25p(&self) -> bool {
+        self._25p
+    }
+
+    pub fn _10p(&self) -> bool {
+        self._10p
+    }
+
+    pub fn min(&self) -> bool {
+        self.min
+    }
+
+    pub fn first(&self) -> bool {
+        self.first
+    }
+
+    pub fn last(&self) -> bool {
+        self.last
+    }
+
+    pub fn cumulative(&self) -> bool {
+        self.cumulative
+    }
+
     pub fn add_first(mut self) -> Self {
         self.first = true;
         self
@@ -790,8 +839,8 @@ impl StorableVecGeneatorOptions {
         self
     }
 
-    pub fn add_total(mut self) -> Self {
-        self.total = true;
+    pub fn add_cumulative(mut self) -> Self {
+        self.cumulative = true;
         self
     }
 
@@ -850,8 +899,8 @@ impl StorableVecGeneatorOptions {
     }
 
     #[allow(unused)]
-    pub fn rm_total(mut self) -> Self {
-        self.total = false;
+    pub fn rm_cumulative(mut self) -> Self {
+        self.cumulative = false;
         self
     }
 
@@ -892,7 +941,7 @@ impl StorableVecGeneatorOptions {
             self.min,
             self.first,
             self.last,
-            self.total,
+            self.cumulative,
         ]
         .iter()
         .filter(|b| **b)
@@ -902,7 +951,7 @@ impl StorableVecGeneatorOptions {
 
     pub fn copy_self_extra(&self) -> Self {
         Self {
-            total: self.total,
+            cumulative: self.cumulative,
             ..Self::default()
         }
     }

crates/brk_computer/src/grouped/builder_lazy.rs

@@ -0,0 +1,395 @@
+use brk_structs::Version;
+use vecdb::{
+    AnyBoxedIterableVec, AnyCloneableIterableVec, AnyCollectableVec, FromCoarserIndex,
+    LazyVecFrom2, StoredIndex,
+};
+
+use crate::grouped::{EagerVecBuilder, VecBuilderOptions};
+
+use super::ComputedType;
+
+#[allow(clippy::type_complexity)]
+#[derive(Clone)]
+pub struct LazyVecBuilder<I, T, S1I, S2T>
+where
+    I: StoredIndex,
+    T: ComputedType,
+    S2T: ComputedType,
+{
+    pub first: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub average: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub sum: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub max: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub min: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub last: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
+    pub cumulative: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<I, T, S1I, S2T> LazyVecBuilder<I, T, S1I, S2T>
+where
+    I: StoredIndex,
+    T: ComputedType + 'static,
+    S1I: StoredIndex + 'static + FromCoarserIndex<I>,
+    S2T: ComputedType,
+{
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        name: &str,
+        version: Version,
+        source: Option<AnyBoxedIterableVec<S1I, T>>,
+        source_extra: &EagerVecBuilder<S1I, T>,
+        len_source: AnyBoxedIterableVec<I, S2T>,
+        options: LazyVecBuilderOptions,
+    ) -> Self {
+        let only_one_active = options.is_only_one_active();
+
+        let suffix = |s: &str| format!("{name}_{s}");
+
+        let maybe_suffix = |s: &str| {
+            if only_one_active {
+                name.to_string()
+            } else {
+                suffix(s)
+            }
+        };
+
+        Self {
+            first: options.first.then(|| {
+                Box::new(LazyVecFrom2::init(
+                    &maybe_suffix("first"),
+                    version + VERSION + Version::ZERO,
+                    source_extra
+                        .first
+                        .as_ref()
+                        .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                    len_source.clone(),
+                    |i: I, source, len_source| {
+                        if i.unwrap_to_usize() >= len_source.len() {
+                            return None;
+                        }
+                        source
+                            .next_at(S1I::min_from(i))
+                            .map(|(_, cow)| cow.into_owned())
+                    },
+                ))
+            }),
+            last: options.last.then(|| {
+                Box::new(LazyVecFrom2::init(
+                    name,
+                    version + VERSION + Version::ZERO,
+                    source_extra.last.as_ref().map_or_else(
+                        || {
+                            source
+                                .as_ref()
+                                .unwrap_or_else(|| {
+                                    dbg!(name, I::to_string());
+                                    panic!()
+                                })
+                                .clone()
+                        },
+                        |v| v.clone(),
+                    ),
+                    len_source.clone(),
+                    |i: I, source, len_source| {
+                        if i.unwrap_to_usize() >= len_source.len() {
+                            return None;
+                        }
+                        source
+                            .next_at(S1I::max_from(i, source.len()))
+                            .map(|(_, cow)| cow.into_owned())
+                    },
+                ))
+            }),
+            min: options.min.then(|| {
+                Box::new(LazyVecFrom2::init(
+                    &maybe_suffix("min"),
+                    version + VERSION + Version::ZERO,
+                    source_extra
+                        .min
+                        .as_ref()
+                        .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                    len_source.clone(),
+                    |i: I, source, len_source| {
+                        if i.unwrap_to_usize() >= len_source.len() {
+                            return None;
+                        }
+                        S1I::inclusive_range_from(i, source.len())
+                            .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                            .min()
+                    },
+                ))
+            }),
+            max: options.max.then(|| {
+                Box::new(LazyVecFrom2::init(
+                    &maybe_suffix("max"),
+                    version + VERSION + Version::ZERO,
+                    source_extra
+                        .max
+                        .as_ref()
+                        .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                    len_source.clone(),
+                    |i: I, source, len_source| {
+                        if i.unwrap_to_usize() >= len_source.len() {
+                            return None;
+                        }
+                        S1I::inclusive_range_from(i, source.len())
+                            .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                            .max()
+                    },
+                ))
+            }),
+            average: options.average.then(|| {
+                Box::new(LazyVecFrom2::init(
+                    &maybe_suffix("average"),
+                    version + VERSION + Version::ZERO,
+                    source_extra
+                        .average
+                        .as_ref()
+                        .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                    len_source.clone(),
+                    |i: I, source, len_source| {
+                        if i.unwrap_to_usize() >= len_source.len() {
+                            return None;
+                        }
+                        let vec = S1I::inclusive_range_from(i, source.len())
+                            .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                            .collect::<Vec<_>>();
+                        if vec.is_empty() {
+                            return None;
+                        }
+                        let mut sum = T::from(0);
+                        let len = vec.len();
+                        vec.into_iter().for_each(|v| sum += v);
+                        Some(sum / len)
+                    },
+                ))
+            }),
+            sum: options.sum.then(|| {
+                Box::new(LazyVecFrom2::init(
+                    &(if !options.last && !options.average && !options.min && !options.max {
+                        name.to_string()
+                    } else {
+                        maybe_suffix("sum")
+                    }),
+                    version + VERSION + Version::ZERO,
+                    source_extra
+                        .sum
+                        .as_ref()
+                        .map_or_else(|| source.as_ref().unwrap().clone(), |v| v.clone()),
+                    len_source.clone(),
+                    |i: I, source, len_source| {
+                        if i.unwrap_to_usize() >= len_source.len() {
+                            return None;
+                        }
+                        let vec = S1I::inclusive_range_from(i, source.len())
+                            .flat_map(|i| source.next_at(i).map(|(_, cow)| cow.into_owned()))
+                            .collect::<Vec<_>>();
+                        if vec.is_empty() {
+                            return None;
+                        }
+                        let mut sum = T::from(0);
+                        vec.into_iter().for_each(|v| sum += v);
+                        Some(sum)
+                    },
+                ))
+            }),
+            cumulative: options.cumulative.then(|| {
+                Box::new(LazyVecFrom2::init(
+                    &suffix("cumulative"),
+                    version + VERSION + Version::ZERO,
+                    source_extra.cumulative.as_ref().unwrap().boxed_clone(),
+                    len_source.clone(),
+                    |i: I, source, len_source| {
+                        if i.unwrap_to_usize() >= len_source.len() {
+                            return None;
+                        }
+                        source
+                            .next_at(S1I::max_from(i, source.len()))
+                            .map(|(_, cow)| cow.into_owned())
+                    },
+                ))
+            }),
+        }
+    }
+
+    pub fn starting_index(&self, max_from: I) -> I {
+        max_from.min(I::from(
+            self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
+        ))
+    }
+
+    pub fn unwrap_first(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
+        self.first.as_ref().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_average(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
+        self.average.as_ref().unwrap()
+    }
+    pub fn unwrap_sum(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
+        self.sum.as_ref().unwrap()
+    }
+    pub fn unwrap_max(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
+        self.max.as_ref().unwrap()
+    }
+    pub fn unwrap_min(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
+        self.min.as_ref().unwrap()
+    }
+    pub fn unwrap_last(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
+        self.last.as_ref().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_cumulative(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
+        self.cumulative.as_ref().unwrap()
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        let mut v: Vec<&dyn AnyCollectableVec> = vec![];
+
+        if let Some(first) = self.first.as_ref() {
+            v.push(first.as_ref());
+        }
+        if let Some(last) = self.last.as_ref() {
+            v.push(last.as_ref());
+        }
+        if let Some(min) = self.min.as_ref() {
+            v.push(min.as_ref());
+        }
+        if let Some(max) = self.max.as_ref() {
+            v.push(max.as_ref());
+        }
+        if let Some(average) = self.average.as_ref() {
+            v.push(average.as_ref());
+        }
+        if let Some(sum) = self.sum.as_ref() {
+            v.push(sum.as_ref());
+        }
+        if let Some(cumulative) = self.cumulative.as_ref() {
+            v.push(cumulative.as_ref());
+        }
+
+        v
+    }
+}
+
+#[derive(Default, Clone, Copy)]
+pub struct LazyVecBuilderOptions {
+    average: bool,
+    sum: bool,
+    max: bool,
+    min: bool,
+    first: bool,
+    last: bool,
+    cumulative: bool,
+}
+
+impl From<VecBuilderOptions> for LazyVecBuilderOptions {
+    fn from(value: VecBuilderOptions) -> Self {
+        Self {
+            average: value.average(),
+            sum: value.sum(),
+            max: value.max(),
+            min: value.min(),
+            first: value.first(),
+            last: value.last(),
+            cumulative: value.cumulative(),
+        }
+    }
+}
+
+impl LazyVecBuilderOptions {
+    pub fn add_first(mut self) -> Self {
+        self.first = true;
+        self
+    }
+
+    pub fn add_last(mut self) -> Self {
+        self.last = true;
+        self
+    }
+
+    pub fn add_min(mut self) -> Self {
+        self.min = true;
+        self
+    }
+
+    pub fn add_max(mut self) -> Self {
+        self.max = true;
+        self
+    }
+
+    pub fn add_average(mut self) -> Self {
+        self.average = true;
+        self
+    }
+
+    pub fn add_sum(mut self) -> Self {
+        self.sum = true;
+        self
+    }
+
+    pub fn add_cumulative(mut self) -> Self {
+        self.cumulative = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_min(mut self) -> Self {
+        self.min = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_max(mut self) -> Self {
+        self.max = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_average(mut self) -> Self {
+        self.average = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_sum(mut self) -> Self {
+        self.sum = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_cumulative(mut self) -> Self {
+        self.cumulative = false;
+        self
+    }
+
+    pub fn add_minmax(mut self) -> Self {
+        self.min = true;
+        self.max = true;
+        self
+    }
+
+    pub fn is_only_one_active(&self) -> bool {
+        [
+            self.average,
+            self.sum,
+            self.max,
+            self.min,
+            self.first,
+            self.last,
+            self.cumulative,
+        ]
+        .iter()
+        .filter(|b| **b)
+        .count()
+            == 1
+    }
+
+    pub fn copy_self_extra(&self) -> Self {
+        Self {
+            cumulative: self.cumulative,
+            ..Self::default()
+        }
+    }
+}

crates/brk_computer/src/grouped/computed.rs

@@ -0,0 +1,23 @@
+use std::ops::{Add, AddAssign, Div};
+
+use vecdb::StoredCompressed;
+
+pub trait ComputedType
+where
+    Self: StoredCompressed
+        + From<usize>
+        + Div<usize, Output = Self>
+        + Add<Output = Self>
+        + AddAssign
+        + Ord,
+{
+}
+impl<T> ComputedType for T where
+    T: StoredCompressed
+        + From<usize>
+        + Div<usize, Output = Self>
+        + Add<Output = Self>
+        + AddAssign
+        + Ord
+{
+}

crates/brk_computer/src/grouped/from_dateindex.rs

@@ -0,0 +1,177 @@
+use brk_error::Result;
+
+use brk_indexer::Indexer;
+use brk_structs::{
+    DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex,
+};
+use vecdb::{AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit};
+
+use crate::{Indexes, grouped::LazyVecBuilder, indexes};
+
+use super::{ComputedType, EagerVecBuilder, Source, VecBuilderOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromDateIndex<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub dateindex: Option<EagerVec<DateIndex, T>>,
+    pub dateindex_extra: EagerVecBuilder<DateIndex, T>,
+    pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
+    pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
+    pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
+    pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
+    pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
+    pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromDateIndex<T>
+where
+    T: ComputedType + 'static,
+{
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        source: Source<DateIndex, T>,
+        version: Version,
+        indexes: &indexes::Vecs,
+        options: VecBuilderOptions,
+    ) -> Result<Self> {
+        let dateindex = source.is_compute().then(|| {
+            EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO).unwrap()
+        });
+
+        let dateindex_extra = EagerVecBuilder::forced_import_compressed(
+            db,
+            name,
+            version + VERSION + Version::ZERO,
+            options.copy_self_extra(),
+        )?;
+
+        let options = options.remove_percentiles();
+
+        let dateindex_source = source.vec().or(dateindex.as_ref().map(|v| v.boxed_clone()));
+
+        Ok(Self {
+            weekindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                dateindex_source.clone(),
+                &dateindex_extra,
+                indexes.weekindex_to_weekindex.boxed_clone(),
+                options.into(),
+            ),
+            monthindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                dateindex_source.clone(),
+                &dateindex_extra,
+                indexes.monthindex_to_monthindex.boxed_clone(),
+                options.into(),
+            ),
+            quarterindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                dateindex_source.clone(),
+                &dateindex_extra,
+                indexes.quarterindex_to_quarterindex.boxed_clone(),
+                options.into(),
+            ),
+            semesterindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                dateindex_source.clone(),
+                &dateindex_extra,
+                indexes.semesterindex_to_semesterindex.boxed_clone(),
+                options.into(),
+            ),
+            yearindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                dateindex_source.clone(),
+                &dateindex_extra,
+                indexes.yearindex_to_yearindex.boxed_clone(),
+                options.into(),
+            ),
+            decadeindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                dateindex_source.clone(),
+                &dateindex_extra,
+                indexes.decadeindex_to_decadeindex.boxed_clone(),
+                options.into(),
+            ),
+            dateindex,
+            dateindex_extra,
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> Result<()>
+    where
+        F: FnMut(
+            &mut EagerVec<DateIndex, T>,
+            &Indexer,
+            &indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(
+            self.dateindex.as_mut().unwrap(),
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        let dateindex: Option<&EagerVec<DateIndex, T>> = None;
+        self.compute_rest(starting_indexes, exit, dateindex)
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        dateindex: Option<&impl AnyIterableVec<DateIndex, T>>,
+    ) -> Result<()> {
+        if let Some(dateindex) = dateindex {
+            self.dateindex_extra
+                .extend(starting_indexes.dateindex, dateindex, exit)?;
+        } else {
+            let dateindex = self.dateindex.as_ref().unwrap();
+
+            self.dateindex_extra
+                .extend(starting_indexes.dateindex, dateindex, exit)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.dateindex
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
+            self.dateindex_extra.vecs(),
+            self.weekindex.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.semesterindex.vecs(),
+            self.yearindex.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/grouped/from_height.rs

@@ -0,0 +1,229 @@
+use brk_error::Result;
+
+use brk_indexer::Indexer;
+use brk_structs::{
+    DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex,
+    Version, WeekIndex, YearIndex,
+};
+use vecdb::{AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit};
+
+use crate::{
+    Indexes,
+    grouped::{LazyVecBuilder, Source},
+    indexes,
+};
+
+use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromHeight<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub height: Option<EagerVec<Height, T>>,
+    pub height_extra: EagerVecBuilder<Height, T>,
+    pub dateindex: EagerVecBuilder<DateIndex, T>,
+    pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
+    pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
+    pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
+    pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
+    pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
+    pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
+    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
+    pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromHeight<T>
+where
+    T: ComputedType + Ord + From<f64> + 'static,
+    f64: From<T>,
+{
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        source: Source<Height, T>,
+        version: Version,
+        indexes: &indexes::Vecs,
+        options: VecBuilderOptions,
+    ) -> Result<Self> {
+        let height = source.is_compute().then(|| {
+            EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO).unwrap()
+        });
+
+        let height_extra = EagerVecBuilder::forced_import_compressed(
+            db,
+            name,
+            version + VERSION + Version::ZERO,
+            options.copy_self_extra(),
+        )?;
+
+        let dateindex = EagerVecBuilder::forced_import_compressed(
+            db,
+            name,
+            version + VERSION + Version::ZERO,
+            options,
+        )?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            weekindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.weekindex_to_weekindex.boxed_clone(),
+                options.into(),
+            ),
+            monthindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.monthindex_to_monthindex.boxed_clone(),
+                options.into(),
+            ),
+            quarterindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.quarterindex_to_quarterindex.boxed_clone(),
+                options.into(),
+            ),
+            semesterindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.semesterindex_to_semesterindex.boxed_clone(),
+                options.into(),
+            ),
+            yearindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.yearindex_to_yearindex.boxed_clone(),
+                options.into(),
+            ),
+            decadeindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.decadeindex_to_decadeindex.boxed_clone(),
+                options.into(),
+            ),
+            // halvingepoch: StorableVecGeneator::forced_import(db, name, version + VERSION + Version::ZERO, format, options)?,
+            height,
+            height_extra,
+            dateindex,
+            difficultyepoch: EagerVecBuilder::forced_import_compressed(
+                db,
+                name,
+                version + VERSION + Version::ZERO,
+                options,
+            )?,
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> Result<()>
+    where
+        F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>,
+    {
+        compute(
+            self.height.as_mut().unwrap(),
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        let height: Option<&EagerVec<Height, T>> = None;
+        self.compute_rest(indexes, starting_indexes, exit, height)
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        height_vec: Option<&impl AnyIterableVec<Height, T>>,
+    ) -> Result<()> {
+        if let Some(height) = height_vec {
+            self.height_extra
+                .extend(starting_indexes.height, height, exit)?;
+
+            self.dateindex.compute(
+                starting_indexes.dateindex,
+                height,
+                &indexes.dateindex_to_first_height,
+                &indexes.dateindex_to_height_count,
+                exit,
+            )?;
+
+            self.difficultyepoch.compute(
+                starting_indexes.difficultyepoch,
+                height,
+                &indexes.difficultyepoch_to_first_height,
+                &indexes.difficultyepoch_to_height_count,
+                exit,
+            )?;
+        } else {
+            let height = self.height.as_ref().unwrap();
+
+            self.height_extra
+                .extend(starting_indexes.height, height, exit)?;
+
+            self.dateindex.compute(
+                starting_indexes.dateindex,
+                height,
+                &indexes.dateindex_to_first_height,
+                &indexes.dateindex_to_height_count,
+                exit,
+            )?;
+
+            self.difficultyepoch.compute(
+                starting_indexes.difficultyepoch,
+                height,
+                &indexes.difficultyepoch_to_first_height,
+                &indexes.difficultyepoch_to_height_count,
+                exit,
+            )?;
+        }
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.height
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
+            self.height_extra.vecs(),
+            self.dateindex.vecs(),
+            self.weekindex.vecs(),
+            self.difficultyepoch.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.semesterindex.vecs(),
+            self.yearindex.vecs(),
+            // self.halvingepoch.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/grouped/from_height_strict.rs

@@ -1,13 +1,12 @@
-use std::path::Path;
+use brk_error::Result;
 
-use brk_core::{DifficultyEpoch, Height};
-use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{AnyCollectableVec, Compressed, EagerVec, Result, Version};
+use brk_structs::{DifficultyEpoch, Height, Version};
+use vecdb::{AnyCollectableVec, Database, EagerVec, Exit};
 
-use crate::vecs::{Indexes, indexes};
+use crate::{Indexes, indexes};
 
-use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
 
 #[derive(Clone)]
 pub struct ComputedVecsFromHeightStrict<T>
@@ -15,8 +14,8 @@ where
     T: ComputedType + PartialOrd,
 {
     pub height: EagerVec<Height, T>,
-    pub height_extra: ComputedVecBuilder<Height, T>,
-    pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
+    pub height_extra: EagerVecBuilder<Height, T>,
+    pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
     // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
 }
 
@@ -28,21 +27,18 @@ where
     f64: From<T>,
 {
     pub fn forced_import(
-        path: &Path,
+        db: &Database,
         name: &str,
         version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let version = VERSION + version;
+        options: VecBuilderOptions,
+    ) -> Result<Self> {
+        let height =
+            EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO)?;
 
-        let height = EagerVec::forced_import(path, name, version, compressed)?;
-
-        let height_extra = ComputedVecBuilder::forced_import(
-            path,
+        let height_extra = EagerVecBuilder::forced_import_compressed(
+            db,
             name,
-            version,
-            compressed,
+            version + VERSION + Version::ZERO,
             options.copy_self_extra(),
         )?;
 
@@ -51,10 +47,13 @@ where
         Ok(Self {
             height,
             height_extra,
-            difficultyepoch: ComputedVecBuilder::forced_import(
-                path, name, version, compressed, options,
+            difficultyepoch: EagerVecBuilder::forced_import_compressed(
+                db,
+                name,
+                version + VERSION + Version::ZERO,
+                options,
             )?,
-            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(db, name, version + VERSION + Version::ZERO, format, options)?,
         })
     }
 
@@ -65,7 +64,7 @@ where
         starting_indexes: &Indexes,
         exit: &Exit,
         mut compute: F,
-    ) -> color_eyre::Result<()>
+    ) -> Result<()>
     where
         F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>,
     {

crates/brk_computer/src/grouped/from_txindex.rs

@@ -1,19 +1,21 @@
-use std::path::Path;
-
-use brk_core::{
-    Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
-    Sats, TxIndex, WeekIndex, YearIndex,
-};
-use brk_exit::Exit;
+use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_vec::{
-    AnyCollectableVec, AnyVec, CollectableVec, Compressed, EagerVec, Result, StoredIndex,
-    VecIterator, Version,
+use brk_structs::{
+    Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
+    Sats, SemesterIndex, TxIndex, Version, WeekIndex, YearIndex,
+};
+use vecdb::{
+    AnyCloneableIterableVec, AnyCollectableVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
+    GenericStoredVec, StoredIndex, VecIterator,
 };
 
-use crate::vecs::{Indexes, fetched, indexes};
+use crate::{
+    Indexes,
+    grouped::{LazyVecBuilder, Source},
+    indexes, price,
+};
 
-use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
 
 #[derive(Clone)]
 pub struct ComputedVecsFromTxindex<T>
@@ -21,60 +23,117 @@ where
     T: ComputedType + PartialOrd,
 {
     pub txindex: Option<Box<EagerVec<TxIndex, T>>>,
-    pub height: ComputedVecBuilder<Height, T>,
-    pub dateindex: ComputedVecBuilder<DateIndex, T>,
-    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
-    pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
-    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
-    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
-    pub yearindex: ComputedVecBuilder<YearIndex, T>,
+    pub height: EagerVecBuilder<Height, T>,
+    pub dateindex: EagerVecBuilder<DateIndex, T>,
+    pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
+    pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
+    pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
+    pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
+    pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
+    pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
     // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
-    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
+    pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
 }
 
 const VERSION: Version = Version::ZERO;
 
 impl<T> ComputedVecsFromTxindex<T>
 where
-    T: ComputedType + Ord + From<f64>,
+    T: ComputedType + Ord + From<f64> + 'static,
     f64: From<T>,
 {
+    #[allow(clippy::too_many_arguments)]
     pub fn forced_import(
-        path: &Path,
+        db: &Database,
         name: &str,
-        compute_source: bool,
+        source: Source<TxIndex, T>,
         version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let version = VERSION + version;
+        indexes: &indexes::Vecs,
+        options: VecBuilderOptions,
+    ) -> Result<Self> {
+        let txindex = source.is_compute().then(|| {
+            Box::new(
+                EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO)
+                    .unwrap(),
+            )
+        });
 
-        let txindex = compute_source
-            .then(|| Box::new(EagerVec::forced_import(path, name, version, compressed).unwrap()));
-
-        let height = ComputedVecBuilder::forced_import(path, name, version, compressed, options)?;
+        let height = EagerVecBuilder::forced_import_compressed(
+            db,
+            name,
+            version + VERSION + Version::ZERO,
+            options,
+        )?;
 
         let options = options.remove_percentiles();
 
+        let dateindex = EagerVecBuilder::forced_import_compressed(
+            db,
+            name,
+            version + VERSION + Version::ZERO,
+            options,
+        )?;
+
         Ok(Self {
+            weekindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.weekindex_to_weekindex.boxed_clone(),
+                options.into(),
+            ),
+            monthindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.monthindex_to_monthindex.boxed_clone(),
+                options.into(),
+            ),
+            quarterindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.quarterindex_to_quarterindex.boxed_clone(),
+                options.into(),
+            ),
+            semesterindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.semesterindex_to_semesterindex.boxed_clone(),
+                options.into(),
+            ),
+            yearindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.yearindex_to_yearindex.boxed_clone(),
+                options.into(),
+            ),
+            decadeindex: LazyVecBuilder::forced_import(
+                name,
+                version + VERSION + Version::ZERO,
+                None,
+                &dateindex,
+                indexes.decadeindex_to_decadeindex.boxed_clone(),
+                options.into(),
+            ),
+
             txindex,
             height,
-            dateindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
-            weekindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
-            difficultyepoch: ComputedVecBuilder::forced_import(
-                path, name, version, compressed, options,
-            )?,
-            monthindex: ComputedVecBuilder::forced_import(
-                path, name, version, compressed, options,
-            )?,
-            quarterindex: ComputedVecBuilder::forced_import(
-                path, name, version, compressed, options,
-            )?,
-            yearindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
-            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
-            decadeindex: ComputedVecBuilder::forced_import(
-                path, name, version, compressed, options,
+            dateindex,
+            difficultyepoch: EagerVecBuilder::forced_import_compressed(
+                db,
+                name,
+                version + VERSION + Version::ZERO,
+                options,
             )?,
+            // halvingepoch: StorableVecGeneator::forced_import(db, name, version + VERSION + Version::ZERO, format, options)?,
         })
     }
 
@@ -86,7 +145,7 @@ where
     //     starting_indexes: &Indexes,
     //     exit: &Exit,
     //     mut compute: F,
-    // ) -> color_eyre::Result<()>
+    // ) -> Result<()>
     // where
     //     F: FnMut(
     //         &mut EagerVec<TxIndex, T>,
@@ -122,7 +181,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,
             )?;
@@ -132,7 +191,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,
             )?;
@@ -155,46 +214,6 @@ where
             exit,
         )?;
 
-        self.weekindex.from_aligned(
-            starting_indexes.weekindex,
-            &self.dateindex,
-            &indexes.weekindex_to_first_dateindex,
-            &indexes.weekindex_to_dateindex_count,
-            exit,
-        )?;
-
-        self.monthindex.from_aligned(
-            starting_indexes.monthindex,
-            &self.dateindex,
-            &indexes.monthindex_to_first_dateindex,
-            &indexes.monthindex_to_dateindex_count,
-            exit,
-        )?;
-
-        self.quarterindex.from_aligned(
-            starting_indexes.quarterindex,
-            &self.monthindex,
-            &indexes.quarterindex_to_first_monthindex,
-            &indexes.quarterindex_to_monthindex_count,
-            exit,
-        )?;
-
-        self.yearindex.from_aligned(
-            starting_indexes.yearindex,
-            &self.monthindex,
-            &indexes.yearindex_to_first_monthindex,
-            &indexes.yearindex_to_monthindex_count,
-            exit,
-        )?;
-
-        self.decadeindex.from_aligned(
-            starting_indexes.decadeindex,
-            &self.yearindex,
-            &indexes.decadeindex_to_first_yearindex,
-            &indexes.decadeindex_to_yearindex_count,
-            exit,
-        )?;
-
         self.difficultyepoch.from_aligned(
             starting_indexes.difficultyepoch,
             &self.height,
@@ -217,6 +236,7 @@ where
             self.difficultyepoch.vecs(),
             self.monthindex.vecs(),
             self.quarterindex.vecs(),
+            self.semesterindex.vecs(),
             self.yearindex.vecs(),
             // self.halvingepoch.vecs(),
             self.decadeindex.vecs(),
@@ -244,11 +264,11 @@ impl ComputedVecsFromTxindex<Bitcoin> {
         };
 
         self.height
-            .validate_computed_version_or_reset_file(txindex_version)?;
+            .validate_computed_version_or_reset(txindex_version)?;
 
         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() {
@@ -383,12 +403,12 @@ impl ComputedVecsFromTxindex<Bitcoin> {
                         exit,
                     )?;
                 }
-                if let Some(total) = self.height.total.as_mut() {
-                    total.forced_push_at(
+                if let Some(cumulative) = self.height.cumulative.as_mut() {
+                    cumulative.forced_push_at(
                         height,
                         Bitcoin::from(
                             sats.height
-                                .unwrap_total()
+                                .unwrap_cumulative()
                                 .into_iter()
                                 .unwrap_get_inner(height),
                         ),
@@ -414,7 +434,7 @@ impl ComputedVecsFromTxindex<Dollars> {
         exit: &Exit,
         bitcoin: &ComputedVecsFromTxindex<Bitcoin>,
         txindex: Option<&impl CollectableVec<TxIndex, Dollars>>,
-        fetched: &fetched::Vecs,
+        price: &price::Vecs,
     ) -> Result<()> {
         let txindex_version = if let Some(txindex) = txindex {
             txindex.version()
@@ -423,13 +443,13 @@ impl ComputedVecsFromTxindex<Dollars> {
         };
 
         self.height
-            .validate_computed_version_or_reset_file(txindex_version)?;
+            .validate_computed_version_or_reset(txindex_version)?;
 
         let starting_index = self.height.starting_index(starting_indexes.height);
 
-        let mut close_iter = fetched.chainindexes_to_close.height.into_iter();
+        let mut close_iter = price.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);
@@ -566,13 +586,13 @@ impl ComputedVecsFromTxindex<Dollars> {
                         exit,
                     )?;
                 }
-                if let Some(total) = self.height.total.as_mut() {
-                    total.forced_push_at(
+                if let Some(cumulative) = self.height.cumulative.as_mut() {
+                    cumulative.forced_push_at(
                         height,
                         price
                             * bitcoin
                                 .height
-                                .unwrap_total()
+                                .unwrap_cumulative()
                                 .into_iter()
                                 .unwrap_get_inner(height),
                         exit,

crates/brk_computer/src/grouped/mod.rs

@@ -1,19 +1,29 @@
-mod builder;
+mod builder_eager;
+mod builder_lazy;
+mod computed;
 mod from_dateindex;
 mod from_height;
 mod from_height_strict;
 mod from_txindex;
 mod ratio_from_dateindex;
-mod r#type;
+mod sd_from_dateindex;
+mod source;
+mod value_from_dateindex;
 mod value_from_height;
 mod value_from_txindex;
+mod value_height;
 
-pub use builder::*;
+pub use builder_eager::*;
+pub use builder_lazy::*;
+use computed::*;
 pub use from_dateindex::*;
 pub use from_height::*;
 pub use from_height_strict::*;
 pub use from_txindex::*;
 pub use ratio_from_dateindex::*;
-use r#type::*;
+pub use sd_from_dateindex::*;
+pub use source::*;
+pub use value_from_dateindex::*;
 pub use value_from_height::*;
 pub use value_from_txindex::*;
+pub use value_height::*;

crates/brk_computer/src/grouped/ratio_from_dateindex.rs

@@ -0,0 +1,712 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version};
+use vecdb::{
+    AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec,
+    Exit, GenericStoredVec, StoredIndex, VecIterator,
+};
+
+use crate::{
+    Indexes,
+    grouped::{ComputedStandardDeviationVecsFromDateIndex, source::Source},
+    indexes, price,
+    utils::get_percentile,
+};
+
+use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
+
+#[derive(Clone)]
+pub struct ComputedRatioVecsFromDateIndex {
+    pub price: Option<ComputedVecsFromDateIndex<Dollars>>,
+
+    pub ratio: ComputedVecsFromDateIndex<StoredF32>,
+    pub ratio_1w_sma: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_1m_sma: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_p99: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_p98: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_p95: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_p5: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_p2: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_p1: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub ratio_p99_as_price: Option<ComputedVecsFromDateIndex<Dollars>>,
+    pub ratio_p98_as_price: Option<ComputedVecsFromDateIndex<Dollars>>,
+    pub ratio_p95_as_price: Option<ComputedVecsFromDateIndex<Dollars>>,
+    pub ratio_p5_as_price: Option<ComputedVecsFromDateIndex<Dollars>>,
+    pub ratio_p2_as_price: Option<ComputedVecsFromDateIndex<Dollars>>,
+    pub ratio_p1_as_price: Option<ComputedVecsFromDateIndex<Dollars>>,
+
+    pub ratio_sd: Option<ComputedStandardDeviationVecsFromDateIndex>,
+    pub ratio_4y_sd: Option<ComputedStandardDeviationVecsFromDateIndex>,
+    pub ratio_2y_sd: Option<ComputedStandardDeviationVecsFromDateIndex>,
+    pub ratio_1y_sd: Option<ComputedStandardDeviationVecsFromDateIndex>,
+}
+
+const VERSION: Version = Version::TWO;
+
+impl ComputedRatioVecsFromDateIndex {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        source: Source<DateIndex, Dollars>,
+        version: Version,
+        indexes: &indexes::Vecs,
+        extended: bool,
+    ) -> Result<Self> {
+        let options = VecBuilderOptions::default().add_last();
+
+        Ok(Self {
+            price: source.is_compute().then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    name,
+                    Source::Compute,
+                    version + VERSION,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_ratio"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            ratio_1w_sma: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_1w_sma"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_1m_sma: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_1m_sma"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_sd: extended.then(|| {
+                ComputedStandardDeviationVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio"),
+                    usize::MAX,
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                )
+                .unwrap()
+            }),
+            ratio_1y_sd: extended.then(|| {
+                ComputedStandardDeviationVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_1y"),
+                    365,
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                )
+                .unwrap()
+            }),
+            ratio_2y_sd: extended.then(|| {
+                ComputedStandardDeviationVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_2y"),
+                    2 * 365,
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                )
+                .unwrap()
+            }),
+            ratio_4y_sd: extended.then(|| {
+                ComputedStandardDeviationVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_4y"),
+                    4 * 365,
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                )
+                .unwrap()
+            }),
+            ratio_p99: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p99"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p98: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p98"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p95: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p95"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p5: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p5"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p2: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p2"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p1: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p1"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p99_as_price: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p99_as_price"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p98_as_price: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p98_as_price"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p95_as_price: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p95_as_price"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p5_as_price: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p5_as_price"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p2_as_price: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p2_as_price"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            ratio_p1_as_price: extended.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_ratio_p1_as_price"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: &price::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        compute: F,
+    ) -> Result<()>
+    where
+        F: FnMut(
+            &mut EagerVec<DateIndex, Dollars>,
+            &Indexer,
+            &indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        self.price.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            compute,
+        )?;
+
+        let date_to_price_opt: Option<&EagerVec<DateIndex, Dollars>> = None;
+        self.compute_rest(
+            indexer,
+            indexes,
+            price,
+            starting_indexes,
+            exit,
+            date_to_price_opt,
+        )
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: &price::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        price_opt: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+    ) -> Result<()> {
+        let closes = price.timeindexes_to_close.dateindex.as_ref().unwrap();
+
+        let price = price_opt.unwrap_or_else(|| unsafe {
+            std::mem::transmute(&self.price.as_ref().unwrap().dateindex)
+        });
+
+        self.ratio.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform2(
+                    starting_indexes.dateindex,
+                    closes,
+                    price,
+                    |(i, close, price, ..)| {
+                        if price == Dollars::ZERO {
+                            (i, StoredF32::from(1.0))
+                        } else {
+                            (i, StoredF32::from(*close / price))
+                        }
+                    },
+                    exit,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        if self.ratio_1w_sma.is_none() {
+            return Ok(());
+        }
+
+        let min_ratio_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
+
+        self.ratio_1w_sma.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_sma_(
+                    starting_indexes.dateindex,
+                    self.ratio.dateindex.as_ref().unwrap(),
+                    7,
+                    exit,
+                    Some(min_ratio_date),
+                )?;
+                Ok(())
+            },
+        )?;
+
+        self.ratio_1m_sma.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_sma_(
+                    starting_indexes.dateindex,
+                    self.ratio.dateindex.as_ref().unwrap(),
+                    30,
+                    exit,
+                    Some(min_ratio_date),
+                )?;
+                Ok(())
+            },
+        )?;
+
+        let ratio_version = self.ratio.dateindex.as_ref().unwrap().version();
+        self.mut_ratio_vecs()
+            .iter_mut()
+            .try_for_each(|v| -> Result<()> {
+                v.validate_computed_version_or_reset(
+                    Version::ZERO + v.inner_version() + ratio_version,
+                )?;
+                Ok(())
+            })?;
+
+        let starting_dateindex = self
+            .mut_ratio_vecs()
+            .iter()
+            .map(|v| DateIndex::from(v.len()))
+            .min()
+            .unwrap()
+            .min(starting_indexes.dateindex);
+
+        let mut sorted = self.ratio.dateindex.as_ref().unwrap().collect_range(
+            Some(min_ratio_date.unwrap_to_usize()),
+            Some(starting_dateindex.unwrap_to_usize()),
+        )?;
+
+        sorted.sort_unstable();
+
+        self.ratio
+            .dateindex
+            .as_ref()
+            .unwrap()
+            .iter_at(starting_dateindex)
+            .try_for_each(|(index, ratio)| -> Result<()> {
+                if index < min_ratio_date {
+                    self.ratio_p5
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, StoredF32::NAN, exit)?;
+                    self.ratio_p2
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, StoredF32::NAN, exit)?;
+                    self.ratio_p1
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, StoredF32::NAN, exit)?;
+                    self.ratio_p95
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, StoredF32::NAN, exit)?;
+                    self.ratio_p98
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, StoredF32::NAN, exit)?;
+                    self.ratio_p99
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, StoredF32::NAN, exit)?;
+                } else {
+                    let ratio = ratio.into_owned();
+                    let pos = sorted.binary_search(&ratio).unwrap_or_else(|pos| pos);
+                    sorted.insert(pos, ratio);
+
+                    self.ratio_p1
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, get_percentile(&sorted, 0.01), exit)?;
+                    self.ratio_p2
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, get_percentile(&sorted, 0.02), exit)?;
+                    self.ratio_p5
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, get_percentile(&sorted, 0.05), exit)?;
+                    self.ratio_p95
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, get_percentile(&sorted, 0.95), exit)?;
+                    self.ratio_p98
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, get_percentile(&sorted, 0.98), exit)?;
+                    self.ratio_p99
+                        .as_mut()
+                        .unwrap()
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, get_percentile(&sorted, 0.99), exit)?;
+                }
+
+                Ok(())
+            })?;
+
+        self.mut_ratio_vecs()
+            .into_iter()
+            .try_for_each(|v| v.safe_flush(exit))?;
+
+        self.ratio_p1.as_mut().unwrap().compute_rest(
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+        self.ratio_p2.as_mut().unwrap().compute_rest(
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+        self.ratio_p5.as_mut().unwrap().compute_rest(
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+        self.ratio_p95.as_mut().unwrap().compute_rest(
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+        self.ratio_p98.as_mut().unwrap().compute_rest(
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+        self.ratio_p99.as_mut().unwrap().compute_rest(
+            starting_indexes,
+            exit,
+            None as Option<&EagerVec<_, _>>,
+        )?;
+
+        let date_to_price = price_opt.unwrap_or_else(|| unsafe {
+            std::mem::transmute(&self.price.as_ref().unwrap().dateindex)
+        });
+
+        self.ratio_p99_as_price.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                let mut iter = self
+                    .ratio_p99
+                    .as_ref()
+                    .unwrap()
+                    .dateindex
+                    .as_ref()
+                    .unwrap()
+                    .into_iter();
+                vec.compute_transform(
+                    starting_indexes.dateindex,
+                    date_to_price,
+                    |(i, price, ..)| {
+                        let multiplier = iter.unwrap_get_inner(i);
+                        (i, price * multiplier)
+                    },
+                    exit,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        let compute_as_price =
+            |as_price: Option<&mut ComputedVecsFromDateIndex<Dollars>>,
+             source: Option<&ComputedVecsFromDateIndex<StoredF32>>| {
+                as_price.unwrap().compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |vec, _, _, starting_indexes, exit| {
+                        let mut iter = source.unwrap().dateindex.as_ref().unwrap().into_iter();
+                        vec.compute_transform(
+                            starting_indexes.dateindex,
+                            date_to_price,
+                            |(i, price, ..)| {
+                                let multiplier = iter.unwrap_get_inner(i);
+                                (i, price * multiplier)
+                            },
+                            exit,
+                        )?;
+                        Ok(())
+                    },
+                )
+            };
+
+        compute_as_price(self.ratio_p1_as_price.as_mut(), self.ratio_p1.as_ref())?;
+        compute_as_price(self.ratio_p2_as_price.as_mut(), self.ratio_p2.as_ref())?;
+        compute_as_price(self.ratio_p5_as_price.as_mut(), self.ratio_p5.as_ref())?;
+        compute_as_price(self.ratio_p95_as_price.as_mut(), self.ratio_p95.as_ref())?;
+        compute_as_price(self.ratio_p98_as_price.as_mut(), self.ratio_p98.as_ref())?;
+        compute_as_price(self.ratio_p99_as_price.as_mut(), self.ratio_p99.as_ref())?;
+
+        self.ratio_sd.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            self.ratio.dateindex.as_ref().unwrap(),
+            Some(date_to_price),
+        )?;
+        self.ratio_4y_sd.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            self.ratio.dateindex.as_ref().unwrap(),
+            Some(date_to_price),
+        )?;
+        self.ratio_2y_sd.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            self.ratio.dateindex.as_ref().unwrap(),
+            Some(date_to_price),
+        )?;
+        self.ratio_1y_sd.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            self.ratio.dateindex.as_ref().unwrap(),
+            Some(date_to_price),
+        )?;
+
+        Ok(())
+    }
+
+    fn mut_ratio_vecs(&mut self) -> Vec<&mut EagerVec<DateIndex, StoredF32>> {
+        [
+            self.ratio_p1
+                .as_mut()
+                .map_or(vec![], |v| vec![v.dateindex.as_mut().unwrap()]),
+            self.ratio_p2
+                .as_mut()
+                .map_or(vec![], |v| vec![v.dateindex.as_mut().unwrap()]),
+            self.ratio_p5
+                .as_mut()
+                .map_or(vec![], |v| vec![v.dateindex.as_mut().unwrap()]),
+            self.ratio_p95
+                .as_mut()
+                .map_or(vec![], |v| vec![v.dateindex.as_mut().unwrap()]),
+            self.ratio_p98
+                .as_mut()
+                .map_or(vec![], |v| vec![v.dateindex.as_mut().unwrap()]),
+            self.ratio_p99
+                .as_mut()
+                .map_or(vec![], |v| vec![v.dateindex.as_mut().unwrap()]),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.price.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio.vecs(),
+            self.ratio_1w_sma.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_1m_sma.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_sd.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_1y_sd.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_2y_sd.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_4y_sd.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p1.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p2.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p5.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p95.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p98.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p99.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p1_as_price.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p2_as_price.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p5_as_price.as_ref().map_or(vec![], |v| v.vecs()),
+            self.ratio_p95_as_price
+                .as_ref()
+                .map_or(vec![], |v| v.vecs()),
+            self.ratio_p98_as_price
+                .as_ref()
+                .map_or(vec![], |v| v.vecs()),
+            self.ratio_p99_as_price
+                .as_ref()
+                .map_or(vec![], |v| v.vecs()),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/grouped/sd_from_dateindex.rs

@@ -0,0 +1,707 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version};
+use vecdb::{
+    AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec,
+    Database, EagerVec, Exit, GenericStoredVec, StoredIndex,
+};
+
+use crate::{Indexes, grouped::source::Source, indexes};
+
+use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
+
+#[derive(Clone)]
+pub struct ComputedStandardDeviationVecsFromDateIndex {
+    days: usize,
+
+    pub sma: Option<ComputedVecsFromDateIndex<StoredF32>>,
+    pub sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub _0sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub p0_5sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub p1sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub p1_5sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub p2sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub p2_5sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub p3sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub m0_5sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub m1sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub m1_5sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub m2sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub m2_5sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub m3sd: ComputedVecsFromDateIndex<StoredF32>,
+    pub p0_5sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub p1sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub p1_5sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub p2sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub p2_5sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub p3sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub m0_5sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub m1sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub m1_5sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub m2sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub m2_5sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub m3sd_as_price: ComputedVecsFromDateIndex<Dollars>,
+    pub zscore: ComputedVecsFromDateIndex<StoredF32>,
+}
+
+const VERSION: Version = Version::ONE;
+
+impl ComputedStandardDeviationVecsFromDateIndex {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        days: usize,
+        source: Source<DateIndex, StoredF32>,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let options = VecBuilderOptions::default().add_last();
+
+        Ok(Self {
+            days,
+            sma: source.is_compute().then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_sma"),
+                    Source::Compute,
+                    version + VERSION + Version::ZERO,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+            sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p0_5sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p0_5sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p1sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p1sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p1_5sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p1_5sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p2sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p2sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p2_5sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p2_5sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p3sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p3sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m0_5sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m0_5sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m1sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m1sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m1_5sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m1_5sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m2sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m2sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m2_5sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m2_5sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m3sd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m3sd"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            _0sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_0sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p0_5sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p0_5sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p1sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p1sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p1_5sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p1_5sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p2sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p2sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p2_5sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p2_5sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            p3sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_p3sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m0_5sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m0_5sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m1sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m1sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m1_5sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m1_5sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m2sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m2sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m2_5sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m2_5sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            m3sd_as_price: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_m3sd_as_price"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+            zscore: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_zscore"),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                options,
+            )?,
+        })
+    }
+
+    pub fn compute_all(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        source: &impl CollectableVec<DateIndex, StoredF32>,
+        source_as_price: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+    ) -> Result<()> {
+        let min_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
+
+        self.sma.as_mut().unwrap().compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_sma_(
+                    starting_indexes.dateindex,
+                    source,
+                    self.days,
+                    exit,
+                    Some(min_date),
+                )?;
+                Ok(())
+            },
+        )?;
+
+        let sma_opt: Option<&EagerVec<DateIndex, StoredF32>> = None;
+        self.compute_rest(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            sma_opt,
+            source,
+            source_as_price,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        sma_opt: Option<&impl AnyIterableVec<DateIndex, StoredF32>>,
+        source: &impl CollectableVec<DateIndex, StoredF32>,
+        source_as_price: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+    ) -> Result<()> {
+        let sma = sma_opt.unwrap_or_else(|| unsafe {
+            std::mem::transmute(&self.sma.as_ref().unwrap().dateindex)
+        });
+
+        let min_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
+
+        let source_version = source.version();
+
+        self.mut_vecs().iter_mut().try_for_each(|v| -> Result<()> {
+            v.validate_computed_version_or_reset(
+                Version::ZERO + v.inner_version() + source_version,
+            )?;
+            Ok(())
+        })?;
+
+        let starting_dateindex = self
+            .mut_vecs()
+            .iter()
+            .map(|v| DateIndex::from(v.len()))
+            .min()
+            .unwrap()
+            .min(starting_indexes.dateindex);
+
+        let mut sorted = source.collect_range(
+            Some(min_date.unwrap_to_usize()),
+            Some(starting_dateindex.unwrap_to_usize()),
+        )?;
+
+        sorted.sort_unstable();
+
+        let mut sma_iter = sma.iter();
+
+        source
+            .iter_at(starting_dateindex)
+            .try_for_each(|(index, ratio)| -> Result<()> {
+                if index < min_date {
+                    self.sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+
+                    self.p0_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.p1sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.p1_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.p2sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.p2_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.p3sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.m0_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.m1sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.m1_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.m2sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.m2_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                    self.m3sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        StoredF32::NAN,
+                        exit,
+                    )?;
+                } else {
+                    let ratio = ratio.into_owned();
+                    let pos = sorted.binary_search(&ratio).unwrap_or_else(|pos| pos);
+                    sorted.insert(pos, ratio);
+
+                    let avg = sma_iter.unwrap_get_inner(index);
+
+                    let population =
+                        index.checked_sub(min_date).unwrap().unwrap_to_usize() as f32 + 1.0;
+
+                    let sd = StoredF32::from(
+                        (sorted.iter().map(|v| (**v - *avg).powi(2)).sum::<f32>() / population)
+                            .sqrt(),
+                    );
+
+                    self.sd
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, sd, exit)?;
+                    self.p0_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg + StoredF32::from(0.5 * *sd),
+                        exit,
+                    )?;
+                    self.p1sd
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, avg + sd, exit)?;
+                    self.p1_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg + StoredF32::from(1.5 * *sd),
+                        exit,
+                    )?;
+                    self.p2sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg + 2 * sd,
+                        exit,
+                    )?;
+                    self.p2_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg + StoredF32::from(2.5 * *sd),
+                        exit,
+                    )?;
+                    self.p3sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg + 3 * sd,
+                        exit,
+                    )?;
+                    self.m0_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg - StoredF32::from(0.5 * *sd),
+                        exit,
+                    )?;
+                    self.m1sd
+                        .dateindex
+                        .as_mut()
+                        .unwrap()
+                        .forced_push_at(index, avg - sd, exit)?;
+                    self.m1_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg - StoredF32::from(1.5 * *sd),
+                        exit,
+                    )?;
+                    self.m2sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg - 2 * sd,
+                        exit,
+                    )?;
+                    self.m2_5sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg - StoredF32::from(2.5 * *sd),
+                        exit,
+                    )?;
+                    self.m3sd.dateindex.as_mut().unwrap().forced_push_at(
+                        index,
+                        avg - 3 * sd,
+                        exit,
+                    )?;
+                }
+
+                Ok(())
+            })?;
+
+        drop(sma_iter);
+
+        self.mut_vecs()
+            .into_iter()
+            .try_for_each(|v| v.safe_flush(exit))?;
+
+        [
+            &mut self.sd,
+            &mut self.p0_5sd,
+            &mut self.p1sd,
+            &mut self.p1_5sd,
+            &mut self.p2sd,
+            &mut self.p2_5sd,
+            &mut self.p3sd,
+            &mut self.m0_5sd,
+            &mut self.m1sd,
+            &mut self.m1_5sd,
+            &mut self.m2sd,
+            &mut self.m2_5sd,
+            &mut self.m3sd,
+        ]
+        .into_iter()
+        .try_for_each(|v| {
+            v.compute_rest(starting_indexes, exit, None as Option<&EagerVec<_, _>>)
+        })?;
+
+        self.zscore.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, _, starting_indexes, exit| {
+                vec.compute_zscore(
+                    starting_indexes.dateindex,
+                    source,
+                    sma,
+                    self.sd.dateindex.as_ref().unwrap(),
+                    exit,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        let Some(price) = source_as_price else {
+            return Ok(());
+        };
+
+        let compute_as_price =
+            |as_price: &mut ComputedVecsFromDateIndex<Dollars>,
+             mut iter: BoxedVecIterator<DateIndex, StoredF32>| {
+                as_price.compute_all(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |vec, _, _, starting_indexes, exit| {
+                        vec.compute_transform(
+                            starting_indexes.dateindex,
+                            price,
+                            |(i, price, ..)| {
+                                let multiplier = iter.unwrap_get_inner(i);
+                                (i, price * multiplier)
+                            },
+                            exit,
+                        )?;
+                        Ok(())
+                    },
+                )
+            };
+
+        compute_as_price(&mut self._0sd_as_price, sma.iter())?;
+        compute_as_price(
+            &mut self.p0_5sd_as_price,
+            self.p0_5sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.p1sd_as_price,
+            self.p1sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.p1_5sd_as_price,
+            self.p1_5sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.p2sd_as_price,
+            self.p2sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.p2_5sd_as_price,
+            self.p2_5sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.p3sd_as_price,
+            self.p3sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.m0_5sd_as_price,
+            self.m0_5sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.m1sd_as_price,
+            self.m1sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.m1_5sd_as_price,
+            self.m1_5sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.m2sd_as_price,
+            self.m2sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.m2_5sd_as_price,
+            self.m2_5sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+        compute_as_price(
+            &mut self.m3sd_as_price,
+            self.m3sd.dateindex.as_ref().unwrap().iter(),
+        )?;
+
+        Ok(())
+    }
+
+    fn mut_vecs(&mut self) -> [&mut EagerVec<DateIndex, StoredF32>; 13] {
+        [
+            self.sd.dateindex.as_mut().unwrap(),
+            self.p0_5sd.dateindex.as_mut().unwrap(),
+            self.p1sd.dateindex.as_mut().unwrap(),
+            self.p1_5sd.dateindex.as_mut().unwrap(),
+            self.p2sd.dateindex.as_mut().unwrap(),
+            self.p2_5sd.dateindex.as_mut().unwrap(),
+            self.p3sd.dateindex.as_mut().unwrap(),
+            self.m0_5sd.dateindex.as_mut().unwrap(),
+            self.m1sd.dateindex.as_mut().unwrap(),
+            self.m1_5sd.dateindex.as_mut().unwrap(),
+            self.m2sd.dateindex.as_mut().unwrap(),
+            self.m2_5sd.dateindex.as_mut().unwrap(),
+            self.m3sd.dateindex.as_mut().unwrap(),
+        ]
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.sma.as_ref().map_or(vec![], |v| v.vecs()),
+            self.sd.vecs(),
+            self.p0_5sd.vecs(),
+            self.p1sd.vecs(),
+            self.p1_5sd.vecs(),
+            self.p2sd.vecs(),
+            self.p2_5sd.vecs(),
+            self.p3sd.vecs(),
+            self.m0_5sd.vecs(),
+            self.m1sd.vecs(),
+            self.m1_5sd.vecs(),
+            self.m2sd.vecs(),
+            self.m2_5sd.vecs(),
+            self.m3sd.vecs(),
+            self._0sd_as_price.vecs(),
+            self.p0_5sd_as_price.vecs(),
+            self.p1sd_as_price.vecs(),
+            self.p1_5sd_as_price.vecs(),
+            self.p2sd_as_price.vecs(),
+            self.p2_5sd_as_price.vecs(),
+            self.p3sd_as_price.vecs(),
+            self.m0_5sd_as_price.vecs(),
+            self.m1sd_as_price.vecs(),
+            self.m1_5sd_as_price.vecs(),
+            self.m2sd_as_price.vecs(),
+            self.m2_5sd_as_price.vecs(),
+            self.m3sd_as_price.vecs(),
+            self.zscore.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/grouped/source.rs

@@ -0,0 +1,51 @@
+use vecdb::AnyBoxedIterableVec;
+
+#[derive(Clone)]
+pub enum Source<I, T> {
+    Compute,
+    None,
+    Vec(AnyBoxedIterableVec<I, T>),
+}
+
+impl<I, T> Source<I, T> {
+    pub fn is_compute(&self) -> bool {
+        matches!(self, Self::Compute)
+    }
+
+    pub fn is_none(&self) -> bool {
+        matches!(self, Self::None)
+    }
+
+    pub fn is_vec(&self) -> bool {
+        matches!(self, Self::Vec(_))
+    }
+
+    pub fn vec(self) -> Option<AnyBoxedIterableVec<I, T>> {
+        match self {
+            Self::Vec(v) => Some(v),
+            _ => None,
+        }
+    }
+}
+
+impl<I, T> From<bool> for Source<I, T> {
+    fn from(value: bool) -> Self {
+        if value { Self::Compute } else { Self::None }
+    }
+}
+
+impl<I, T> From<AnyBoxedIterableVec<I, T>> for Source<I, T> {
+    fn from(value: AnyBoxedIterableVec<I, T>) -> Self {
+        Self::Vec(value)
+    }
+}
+
+impl<I, T> From<Option<AnyBoxedIterableVec<I, T>>> for Source<I, T> {
+    fn from(value: Option<AnyBoxedIterableVec<I, T>>) -> Self {
+        if let Some(v) = value {
+            Self::Vec(v)
+        } else {
+            Self::None
+        }
+    }
+}

crates/brk_computer/src/grouped/value_from_dateindex.rs

@@ -0,0 +1,179 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version};
+use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
+
+use crate::{
+    Indexes,
+    grouped::ComputedVecsFromDateIndex,
+    indexes, price,
+    traits::{ComputeFromBitcoin, ComputeFromSats},
+};
+
+use super::{Source, VecBuilderOptions};
+
+#[derive(Clone)]
+pub struct ComputedValueVecsFromDateIndex {
+    pub sats: ComputedVecsFromDateIndex<Sats>,
+    pub bitcoin: ComputedVecsFromDateIndex<Bitcoin>,
+    pub dollars: Option<ComputedVecsFromDateIndex<Dollars>>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl ComputedValueVecsFromDateIndex {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        source: Source<DateIndex, Sats>,
+        version: Version,
+        options: VecBuilderOptions,
+        compute_dollars: bool,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self {
+            sats: ComputedVecsFromDateIndex::forced_import(
+                db,
+                name,
+                source,
+                version + VERSION,
+                indexes,
+                options,
+            )?,
+            bitcoin: ComputedVecsFromDateIndex::forced_import(
+                db,
+                &format!("{name}_in_btc"),
+                Source::Compute,
+                version + VERSION,
+                indexes,
+                options,
+            )?,
+            dollars: compute_dollars.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    db,
+                    &format!("{name}_in_usd"),
+                    Source::Compute,
+                    version + VERSION,
+                    indexes,
+                    options,
+                )
+                .unwrap()
+            }),
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> Result<()>
+    where
+        F: FnMut(
+            &mut EagerVec<DateIndex, Sats>,
+            &Indexer,
+            &indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(
+            self.sats.dateindex.as_mut().unwrap(),
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        let dateindex: Option<&StoredVec<DateIndex, Sats>> = None;
+        self.compute_rest(indexer, indexes, price, starting_indexes, exit, dateindex)?;
+
+        Ok(())
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        dateindex: Option<&impl CollectableVec<DateIndex, Sats>>,
+    ) -> Result<()> {
+        if let Some(dateindex) = dateindex {
+            self.sats
+                .compute_rest(starting_indexes, exit, Some(dateindex))?;
+
+            self.bitcoin.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_sats(starting_indexes.dateindex, dateindex, exit)
+                },
+            )?;
+        } else {
+            let dateindex: Option<&StoredVec<DateIndex, Sats>> = None;
+
+            self.sats.compute_rest(starting_indexes, exit, dateindex)?;
+
+            self.bitcoin.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_sats(
+                        starting_indexes.dateindex,
+                        self.sats.dateindex.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+        }
+
+        let dateindex_to_bitcoin = self.bitcoin.dateindex.as_ref().unwrap();
+        let dateindex_to_close = price
+            .as_ref()
+            .unwrap()
+            .timeindexes_to_close
+            .dateindex
+            .as_ref()
+            .unwrap();
+
+        if let Some(dollars) = self.dollars.as_mut() {
+            dollars.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_bitcoin(
+                        starting_indexes.dateindex,
+                        dateindex_to_bitcoin,
+                        dateindex_to_close,
+                        exit,
+                    )
+                },
+            )?;
+        }
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.sats.vecs(),
+            self.bitcoin.vecs(),
+            self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/grouped/value_from_height.rs

@@ -1,15 +1,16 @@
-use std::path::Path;
-
-use brk_core::{Bitcoin, Dollars, Height, Sats};
-use brk_exit::Exit;
+use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_vec::{
-    AnyCollectableVec, CollectableVec, Compressed, EagerVec, Result, StoredVec, Version,
+use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
+use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
+
+use crate::{
+    Indexes,
+    grouped::Source,
+    indexes, price,
+    traits::{ComputeFromBitcoin, ComputeFromSats},
 };
 
-use crate::vecs::{Indexes, fetched, indexes};
-
-use super::{ComputedVecsFromHeight, StorableVecGeneatorOptions};
+use super::{ComputedVecsFromHeight, VecBuilderOptions};
 
 #[derive(Clone)]
 pub struct ComputedValueVecsFromHeight {
@@ -18,42 +19,43 @@ pub struct ComputedValueVecsFromHeight {
     pub dollars: Option<ComputedVecsFromHeight<Dollars>>,
 }
 
-const VERSION: Version = Version::ONE;
+const VERSION: Version = Version::ZERO;
 
 impl ComputedValueVecsFromHeight {
+    #[allow(clippy::too_many_arguments)]
     pub fn forced_import(
-        path: &Path,
+        db: &Database,
         name: &str,
-        compute_source: bool,
+        source: Source<Height, Sats>,
         version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
+        options: VecBuilderOptions,
         compute_dollars: bool,
-    ) -> color_eyre::Result<Self> {
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
         Ok(Self {
             sats: ComputedVecsFromHeight::forced_import(
-                path,
+                db,
                 name,
-                compute_source,
-                VERSION + version,
-                compressed,
+                source,
+                version + VERSION,
+                indexes,
                 options,
             )?,
             bitcoin: ComputedVecsFromHeight::forced_import(
-                path,
+                db,
                 &format!("{name}_in_btc"),
-                true,
-                VERSION + version,
-                compressed,
+                Source::Compute,
+                version + VERSION,
+                indexes,
                 options,
             )?,
             dollars: compute_dollars.then(|| {
                 ComputedVecsFromHeight::forced_import(
-                    path,
+                    db,
                     &format!("{name}_in_usd"),
-                    true,
-                    VERSION + version,
-                    compressed,
+                    Source::Compute,
+                    version + VERSION,
+                    indexes,
                     options,
                 )
                 .unwrap()
@@ -65,11 +67,11 @@ impl ComputedValueVecsFromHeight {
         &mut self,
         indexer: &Indexer,
         indexes: &indexes::Vecs,
-        fetched: Option<&fetched::Vecs>,
+        price: Option<&price::Vecs>,
         starting_indexes: &Indexes,
         exit: &Exit,
         mut compute: F,
-    ) -> color_eyre::Result<()>
+    ) -> Result<()>
     where
         F: FnMut(
             &mut EagerVec<Height, Sats>,
@@ -88,7 +90,7 @@ impl ComputedValueVecsFromHeight {
         )?;
 
         let height: Option<&StoredVec<Height, Sats>> = None;
-        self.compute_rest(indexer, indexes, fetched, starting_indexes, exit, height)?;
+        self.compute_rest(indexer, indexes, price, starting_indexes, exit, height)?;
 
         Ok(())
     }
@@ -97,11 +99,11 @@ impl ComputedValueVecsFromHeight {
         &mut self,
         indexer: &Indexer,
         indexes: &indexes::Vecs,
-        fetched: Option<&fetched::Vecs>,
+        price: Option<&price::Vecs>,
         starting_indexes: &Indexes,
         exit: &Exit,
         height: Option<&impl CollectableVec<Height, Sats>>,
-    ) -> color_eyre::Result<()> {
+    ) -> Result<()> {
         if let Some(height) = height {
             self.sats
                 .compute_rest(indexes, starting_indexes, exit, Some(height))?;
@@ -129,15 +131,15 @@ impl ComputedValueVecsFromHeight {
                 |v, _, _, starting_indexes, exit| {
                     v.compute_from_sats(
                         starting_indexes.height,
-                        self.sats.height.as_ref().unwrap().as_ref(),
+                        self.sats.height.as_ref().unwrap(),
                         exit,
                     )
                 },
             )?;
         }
 
-        let height_to_bitcoin = self.bitcoin.height.as_ref().unwrap().as_ref();
-        let height_to_close = &fetched.as_ref().unwrap().chainindexes_to_close.height;
+        let height_to_bitcoin = self.bitcoin.height.as_ref().unwrap();
+        let height_to_close = &price.as_ref().unwrap().chainindexes_to_close.height;
 
         if let Some(dollars) = self.dollars.as_mut() {
             dollars.compute_all(

crates/brk_computer/src/grouped/value_from_txindex.rs

@@ -1,16 +1,14 @@
-use std::path::Path;
-
-use brk_core::{Bitcoin, Close, Dollars, Height, Sats, TxIndex};
-use brk_exit::Exit;
+use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_vec::{
-    AnyCollectableVec, BoxedAnyIterableVec, CloneableAnyIterableVec, CollectableVec, Compressed,
-    Computation, ComputedVecFrom3, LazyVecFrom1, StoredIndex, StoredVec, Version,
+use brk_structs::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
+use vecdb::{
+    AnyCloneableIterableVec, AnyCollectableVec, CollectableVec, Database, Exit, LazyVecFrom1,
+    LazyVecFrom3, StoredIndex, StoredVec,
 };
 
-use crate::vecs::{Indexes, fetched, indexes};
+use crate::{Indexes, grouped::Source, indexes, price};
 
-use super::{ComputedVecsFromTxindex, StorableVecGeneatorOptions};
+use super::{ComputedVecsFromTxindex, VecBuilderOptions};
 
 #[derive(Clone)]
 pub struct ComputedValueVecsFromTxindex {
@@ -19,100 +17,86 @@ pub struct ComputedValueVecsFromTxindex {
     pub bitcoin: ComputedVecsFromTxindex<Bitcoin>,
     #[allow(clippy::type_complexity)]
     pub dollars_txindex: Option<
-        ComputedVecFrom3<
-            TxIndex,
-            Dollars,
-            TxIndex,
-            Bitcoin,
-            TxIndex,
-            Height,
-            Height,
-            Close<Dollars>,
-        >,
+        LazyVecFrom3<TxIndex, Dollars, TxIndex, Bitcoin, TxIndex, Height, Height, Close<Dollars>>,
     >,
     pub dollars: Option<ComputedVecsFromTxindex<Dollars>>,
 }
 
-const VERSION: Version = Version::ONE;
+const VERSION: Version = Version::ZERO;
 
 impl ComputedValueVecsFromTxindex {
     #[allow(clippy::too_many_arguments)]
     pub fn forced_import(
-        path: &Path,
+        db: &Database,
         name: &str,
         indexes: &indexes::Vecs,
-        source: Option<BoxedAnyIterableVec<TxIndex, Sats>>,
+        source: Source<TxIndex, Sats>,
         version: Version,
-        computation: Computation,
-        compressed: Compressed,
-        fetched: Option<&fetched::Vecs>,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let compute_source = source.is_none();
-        let compute_dollars = fetched.is_some();
+        price: Option<&price::Vecs>,
+        options: VecBuilderOptions,
+    ) -> Result<Self> {
+        let compute_dollars = price.is_some();
 
         let name_in_btc = format!("{name}_in_btc");
         let name_in_usd = format!("{name}_in_usd");
 
         let sats = ComputedVecsFromTxindex::forced_import(
-            path,
+            db,
             name,
-            compute_source,
-            VERSION + version,
-            compressed,
+            source.clone(),
+            version + VERSION,
+            indexes,
             options,
         )?;
 
+        let source_vec = source.vec();
+
         let bitcoin_txindex = LazyVecFrom1::init(
             &name_in_btc,
-            VERSION + version,
-            source.map_or_else(|| sats.txindex.as_ref().unwrap().boxed_clone(), |s| s),
+            version + VERSION,
+            source_vec.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)
                 })
             },
         );
 
         let bitcoin = ComputedVecsFromTxindex::forced_import(
-            path,
+            db,
             &name_in_btc,
-            false,
-            VERSION + version,
-            compressed,
+            Source::None,
+            version + VERSION,
+            indexes,
             options,
         )?;
 
-        let dollars_txindex = fetched.map(|fetched| {
-            ComputedVecFrom3::forced_import_or_init_from_3(
-                computation,
-                path,
+        let dollars_txindex = price.map(|price| {
+            LazyVecFrom3::init(
                 &name_in_usd,
-                VERSION + version,
-                compressed,
+                version + VERSION,
                 bitcoin_txindex.boxed_clone(),
                 indexes.txindex_to_height.boxed_clone(),
-                fetched.chainindexes_to_close.height.boxed_clone(),
+                price.chainindexes_to_close.height.boxed_clone(),
                 |txindex: TxIndex,
                  txindex_to_btc_iter,
                  txindex_to_height_iter,
                  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)
                             })
                     })
                 },
             )
-            .unwrap()
         });
 
         Ok(Self {
@@ -122,11 +106,11 @@ impl ComputedValueVecsFromTxindex {
             dollars_txindex,
             dollars: compute_dollars.then(|| {
                 ComputedVecsFromTxindex::forced_import(
-                    path,
+                    db,
                     &name_in_usd,
-                    false,
-                    VERSION + version,
-                    compressed,
+                    Source::None,
+                    version + VERSION,
+                    indexes,
                     options,
                 )
                 .unwrap()
@@ -138,11 +122,11 @@ impl ComputedValueVecsFromTxindex {
     //     &mut self,
     //     indexer: &Indexer,
     //     indexes: &indexes::Vecs,
-    //     fetched: Option<&marketprice::Vecs>,
+    //     price: Option<&marketprice::Vecs>,
     //     starting_indexes: &Indexes,
     //     exit: &Exit,
     //     mut compute: F,
-    // ) -> color_eyre::Result<()>
+    // ) -> Result<()>
     // where
     //     F: FnMut(
     //         &mut EagerVec<TxIndex, Sats>,
@@ -180,8 +164,8 @@ impl ComputedValueVecsFromTxindex {
         starting_indexes: &Indexes,
         exit: &Exit,
         txindex: Option<&impl CollectableVec<TxIndex, Sats>>,
-        fetched: Option<&fetched::Vecs>,
-    ) -> color_eyre::Result<()> {
+        price: Option<&price::Vecs>,
+    ) -> Result<()> {
         if let Some(txindex) = txindex {
             self.sats
                 .compute_rest(indexer, indexes, starting_indexes, exit, Some(txindex))?;
@@ -203,8 +187,6 @@ impl ComputedValueVecsFromTxindex {
         if let Some(dollars) = self.dollars.as_mut() {
             let dollars_txindex = self.dollars_txindex.as_mut().unwrap();
 
-            dollars_txindex.compute_if_necessary(starting_indexes.txindex, exit)?;
-
             dollars.compute_rest_from_bitcoin(
                 indexer,
                 indexes,
@@ -212,7 +194,7 @@ impl ComputedValueVecsFromTxindex {
                 exit,
                 &self.bitcoin,
                 Some(dollars_txindex),
-                fetched.as_ref().unwrap(),
+                price.as_ref().unwrap(),
             )?;
         }
 
@@ -222,7 +204,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()

crates/brk_computer/src/grouped/value_height.rs

@@ -0,0 +1,129 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
+use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, Format, StoredVec};
+
+use crate::{
+    Indexes,
+    grouped::Source,
+    indexes, price,
+    traits::{ComputeFromBitcoin, ComputeFromSats},
+};
+
+#[derive(Clone)]
+pub struct ComputedHeightValueVecs {
+    pub sats: Option<EagerVec<Height, Sats>>,
+    pub bitcoin: EagerVec<Height, Bitcoin>,
+    pub dollars: Option<EagerVec<Height, Dollars>>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl ComputedHeightValueVecs {
+    pub fn forced_import(
+        db: &Database,
+        name: &str,
+        source: Source<Height, Sats>,
+        version: Version,
+        format: Format,
+        compute_dollars: bool,
+    ) -> Result<Self> {
+        Ok(Self {
+            sats: source.is_compute().then(|| {
+                EagerVec::forced_import(db, name, version + VERSION + Version::ZERO, format)
+                    .unwrap()
+            }),
+            bitcoin: EagerVec::forced_import(
+                db,
+                &format!("{name}_in_btc"),
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+            dollars: compute_dollars.then(|| {
+                EagerVec::forced_import(
+                    db,
+                    &format!("{name}_in_usd"),
+                    version + VERSION + Version::ZERO,
+                    format,
+                )
+                .unwrap()
+            }),
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> Result<()>
+    where
+        F: FnMut(
+            &mut EagerVec<Height, Sats>,
+            &Indexer,
+            &indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(
+            self.sats.as_mut().unwrap(),
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        let height: Option<&StoredVec<Height, Sats>> = None;
+        self.compute_rest(price, starting_indexes, exit, height)?;
+
+        Ok(())
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        height: Option<&impl CollectableVec<Height, Sats>>,
+    ) -> Result<()> {
+        if let Some(height) = height {
+            self.bitcoin
+                .compute_from_sats(starting_indexes.height, height, exit)?;
+        } else {
+            self.bitcoin.compute_from_sats(
+                starting_indexes.height,
+                self.sats.as_ref().unwrap(),
+                exit,
+            )?;
+        }
+
+        let height_to_bitcoin = &self.bitcoin;
+        let height_to_close = &price.as_ref().unwrap().chainindexes_to_close.height;
+
+        if let Some(dollars) = self.dollars.as_mut() {
+            dollars.compute_from_bitcoin(
+                starting_indexes.height,
+                height_to_bitcoin,
+                height_to_close,
+                exit,
+            )?;
+        }
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            vec![&self.bitcoin as &dyn AnyCollectableVec],
+            self.sats.as_ref().map_or(vec![], |v| vec![v]),
+            self.dollars.as_ref().map_or(vec![], |v| vec![v]),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}

crates/brk_computer/src/lib.rs

@@ -1,84 +1,181 @@
 #![doc = include_str!("../README.md")]
-#![doc = "\n## Example\n\n```rust"]
-#![doc = include_str!("../examples/main.rs")]
-#![doc = "```"]
 
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
-use brk_exit::Exit;
+use brk_error::Result;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
-pub use brk_parser::rpc;
-use brk_vec::{AnyCollectableVec, Compressed, Computation};
-
-mod states;
-mod stores;
-mod utils;
-mod vecs;
-
+use brk_structs::Version;
 use log::info;
-use stores::Stores;
-use vecs::Vecs;
+use vecdb::{AnyCollectableVec, Exit, Format};
+
+mod blocks;
+mod cointime;
+mod constants;
+mod fetched;
+mod grouped;
+mod indexes;
+mod market;
+mod mining;
+mod price;
+mod stateful;
+mod states;
+mod traits;
+mod transactions;
+mod utils;
+
+use indexes::Indexes;
+
+pub use states::PriceToAmount;
+use states::*;
 
 #[derive(Clone)]
 pub struct Computer {
-    path: PathBuf,
-    fetcher: Option<Fetcher>,
-    vecs: Option<Vecs>,
-    stores: Option<Stores>,
-    compressed: Compressed,
+    pub indexes: indexes::Vecs,
+    pub constants: constants::Vecs,
+    pub blocks: blocks::Vecs,
+    pub mining: mining::Vecs,
+    pub market: market::Vecs,
+    pub price: Option<price::Vecs>,
+    pub transactions: transactions::Vecs,
+    pub stateful: stateful::Vecs,
+    pub fetched: Option<fetched::Vecs>,
+    pub cointime: cointime::Vecs,
 }
 
+const VERSION: Version = Version::TWO;
+
 impl Computer {
-    pub fn new(outputs_dir: &Path, fetcher: Option<Fetcher>, compressed: bool) -> Self {
-        Self {
-            path: outputs_dir.to_owned(),
-            fetcher,
-            vecs: None,
-            stores: None,
-            compressed: Compressed::from(compressed),
-        }
-    }
-
-    pub fn import_vecs(
-        &mut self,
-        indexer: &Indexer,
-        computation: Computation,
-    ) -> color_eyre::Result<()> {
-        self.vecs = Some(Vecs::import(
-            &self.path.join("vecs/computed"),
-            indexer,
-            self.fetcher.is_some(),
-            computation,
-            self.compressed,
-        )?);
-        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(
-            &self.path.join("stores"),
-            indexer.keyspace(),
-        )?);
-        Ok(())
-    }
-}
+    pub fn forced_import(
+        outputs_path: &Path,
+        indexer: &Indexer,
+        fetcher: Option<Fetcher>,
+    ) -> Result<Self> {
+        info!("Importing computer...");
+
+        let computed_path = outputs_path.join("computed");
+
+        let indexes =
+            indexes::Vecs::forced_import(&computed_path, VERSION + Version::ZERO, indexer)?;
+
+        let fetched = fetcher.map(|fetcher| {
+            fetched::Vecs::forced_import(outputs_path, fetcher, VERSION + Version::ZERO).unwrap()
+        });
+
+        let price = fetched.is_some().then(|| {
+            price::Vecs::forced_import(&computed_path, VERSION + Version::ZERO, &indexes).unwrap()
+        });
+
+        Ok(Self {
+            blocks: blocks::Vecs::forced_import(&computed_path, VERSION + Version::ZERO, &indexes)?,
+            mining: mining::Vecs::forced_import(&computed_path, VERSION + Version::ZERO, &indexes)?,
+            constants: constants::Vecs::forced_import(
+                &computed_path,
+                VERSION + Version::ZERO,
+                &indexes,
+            )?,
+            market: market::Vecs::forced_import(&computed_path, VERSION + Version::ZERO, &indexes)?,
+            stateful: stateful::Vecs::forced_import(
+                &computed_path,
+                VERSION + Version::ZERO,
+                Format::Compressed,
+                &indexes,
+                price.as_ref(),
+            )?,
+            transactions: transactions::Vecs::forced_import(
+                &computed_path,
+                VERSION + Version::ZERO,
+                indexer,
+                &indexes,
+                price.as_ref(),
+            )?,
+            cointime: cointime::Vecs::forced_import(
+                &computed_path,
+                VERSION + Version::ZERO,
+                &indexes,
+                price.as_ref(),
+            )?,
+            indexes,
+            fetched,
+            price,
+        })
+    }
 
-impl Computer {
     pub fn compute(
         &mut self,
-        indexer: &mut Indexer,
+        indexer: &Indexer,
         starting_indexes: brk_indexer::Indexes,
         exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        info!("Computing...");
+    ) -> Result<()> {
+        info!("Computing indexes...");
+        let mut starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
 
-        self.vecs.as_mut().unwrap().compute(
+        info!("Computing constants...");
+        self.constants
+            .compute(indexer, &self.indexes, &starting_indexes, exit)?;
+
+        info!("Computing blocks...");
+        self.blocks
+            .compute(indexer, &self.indexes, &starting_indexes, exit)?;
+
+        info!("Computing mining...");
+        self.mining
+            .compute(indexer, &self.indexes, &starting_indexes, exit)?;
+
+        if let Some(fetched) = self.fetched.as_mut() {
+            info!("Computing fetched...");
+            fetched.compute(indexer, &self.indexes, &starting_indexes, exit)?;
+
+            info!("Computing prices...");
+            self.price.as_mut().unwrap().compute(
+                indexer,
+                &self.indexes,
+                &starting_indexes,
+                fetched,
+                exit,
+            )?;
+        }
+
+        info!("Computing transactions...");
+        self.transactions.compute(
             indexer,
-            starting_indexes,
-            self.fetcher.as_mut(),
+            &self.indexes,
+            &starting_indexes,
+            self.price.as_ref(),
+            exit,
+        )?;
+
+        if let Some(price) = self.price.as_ref() {
+            info!("Computing market...");
+            self.market.compute(
+                indexer,
+                &self.indexes,
+                price,
+                &mut self.transactions,
+                &starting_indexes,
+                exit,
+            )?;
+        }
+
+        info!("Computing stateful...");
+        self.stateful.compute(
+            indexer,
+            &self.indexes,
+            &self.transactions,
+            self.price.as_ref(),
+            &self.market,
+            &mut starting_indexes,
+            exit,
+        )?;
+
+        self.cointime.compute(
+            indexer,
+            &self.indexes,
+            &starting_indexes,
+            self.price.as_ref(),
+            &self.transactions,
+            &self.stateful,
             exit,
         )?;
 
@@ -86,19 +183,24 @@ impl Computer {
     }
 
     pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
-        // pub fn vecs(&self) -> &Vecs {
-        self.vecs.as_ref().unwrap().vecs()
+        [
+            self.constants.vecs(),
+            self.indexes.vecs(),
+            self.blocks.vecs(),
+            self.mining.vecs(),
+            self.market.vecs(),
+            self.transactions.vecs(),
+            self.stateful.vecs(),
+            self.cointime.vecs(),
+            self.fetched.as_ref().map_or(vec![], |v| v.vecs()),
+            self.price.as_ref().map_or(vec![], |v| v.vecs()),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
     }
 
-    // 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()
+    pub fn static_clone(&self) -> &'static Self {
+        Box::leak(Box::new(self.clone()))
     }
 }

crates/brk_computer/src/mining.rs

@@ -1,54 +1,61 @@
-use std::{fs, path::Path};
+use std::path::Path;
 
-use brk_core::{DifficultyEpoch, HalvingEpoch, StoredF64};
-use brk_exit::Exit;
+use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_vec::{AnyCollectableVec, Compressed, Computation, VecIterator, Version};
+use brk_structs::{DifficultyEpoch, HalvingEpoch, StoredF64, Version};
+use vecdb::{AnyCollectableVec, Database, Exit, PAGE_SIZE, VecIterator};
+
+use crate::grouped::Source;
 
 use super::{
     Indexes,
-    grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, VecBuilderOptions},
     indexes,
 };
 
+const VERSION: Version = Version::ZERO;
+
 #[derive(Clone)]
 pub struct Vecs {
+    db: Database,
+
     pub indexes_to_difficulty: ComputedVecsFromHeight<StoredF64>,
     pub indexes_to_difficultyepoch: ComputedVecsFromDateIndex<DifficultyEpoch>,
     pub indexes_to_halvingepoch: ComputedVecsFromDateIndex<HalvingEpoch>,
 }
 
 impl Vecs {
-    pub fn forced_import(
-        path: &Path,
-        _computation: Computation,
-        compressed: Compressed,
-    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
+    pub fn forced_import(parent: &Path, version: Version, indexes: &indexes::Vecs) -> Result<Self> {
+        let db = Database::open(&parent.join("mining"))?;
+        db.set_min_len(PAGE_SIZE * 1_000_000)?;
 
         Ok(Self {
             indexes_to_difficulty: ComputedVecsFromHeight::forced_import(
-                path,
+                &db,
                 "difficulty",
-                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_last(),
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
             )?,
             indexes_to_difficultyepoch: ComputedVecsFromDateIndex::forced_import(
-                path,
+                &db,
                 "difficultyepoch",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_last(),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
             )?,
             indexes_to_halvingepoch: ComputedVecsFromDateIndex::forced_import(
-                path,
+                &db,
                 "halvingepoch",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_last(),
+                Source::Compute,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
             )?,
+
+            db,
         })
     }
 
@@ -58,9 +65,21 @@ impl Vecs {
         indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
-    ) -> color_eyre::Result<()> {
+    ) -> Result<()> {
+        self.compute_(indexer, indexes, starting_indexes, exit)?;
+        self.db.flush_then_punch()?;
+        Ok(())
+    }
+
+    fn compute_(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
         let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.into_iter();
-        self.indexes_to_difficultyepoch.compute(
+        self.indexes_to_difficultyepoch.compute_all(
             indexer,
             indexes,
             starting_indexes,
@@ -79,12 +98,13 @@ impl Vecs {
                         )
                     },
                     exit,
-                )
+                )?;
+                Ok(())
             },
         )?;
 
         let mut height_to_halvingepoch_iter = indexes.height_to_halvingepoch.into_iter();
-        self.indexes_to_halvingepoch.compute(
+        self.indexes_to_halvingepoch.compute_all(
             indexer,
             indexes,
             starting_indexes,
@@ -103,7 +123,8 @@ impl Vecs {
                         )
                     },
                     exit,
-                )
+                )?;
+                Ok(())
             },
         )?;
 
@@ -111,7 +132,7 @@ impl Vecs {
             indexes,
             starting_indexes,
             exit,
-            Some(&indexer.vecs().height_to_difficulty),
+            Some(&indexer.vecs.height_to_difficulty),
         )?;
 
         Ok(())

crates/brk_computer/src/stateful/address_cohort.rs

@@ -0,0 +1,258 @@
+use std::{ops::Deref, path::Path};
+
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
+use vecdb::{
+    AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
+    GenericStoredVec, VecIterator,
+};
+
+use crate::{
+    Indexes,
+    grouped::{ComputedVecsFromHeight, Source, VecBuilderOptions},
+    indexes, market, price,
+    stateful::{
+        common,
+        r#trait::{CohortVecs, DynCohortVecs},
+    },
+    states::AddressCohortState,
+};
+
+const VERSION: Version = Version::ZERO;
+
+#[derive(Clone)]
+pub struct Vecs {
+    starting_height: Option<Height>,
+
+    pub state: Option<AddressCohortState>,
+
+    pub inner: common::Vecs,
+
+    pub height_to_address_count: EagerVec<Height, StoredU64>,
+    pub indexes_to_address_count: ComputedVecsFromHeight<StoredU64>,
+}
+
+impl Vecs {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        cohort_name: Option<&str>,
+        format: Format,
+        version: Version,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        states_path: Option<&Path>,
+        compute_relative_to_all: bool,
+    ) -> Result<Self> {
+        let compute_dollars = price.is_some();
+
+        let suffix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{name}_{s}"));
+
+        Ok(Self {
+            starting_height: None,
+            state: states_path.map(|states_path| {
+                AddressCohortState::new(
+                    states_path,
+                    cohort_name.unwrap_or_default(),
+                    compute_dollars,
+                )
+            }),
+            height_to_address_count: EagerVec::forced_import(
+                db,
+                &suffix("address_count"),
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+            indexes_to_address_count: ComputedVecsFromHeight::forced_import(
+                db,
+                &suffix("address_count"),
+                Source::None,
+                version + VERSION + Version::ZERO,
+                indexes,
+                VecBuilderOptions::default().add_last(),
+            )?,
+            inner: common::Vecs::forced_import(
+                db,
+                cohort_name,
+                format,
+                version,
+                indexes,
+                price,
+                compute_relative_to_all,
+                false,
+                false,
+            )?,
+        })
+    }
+}
+
+impl DynCohortVecs for Vecs {
+    fn min_height_vecs_len(&self) -> usize {
+        [
+            self.height_to_address_count.len(),
+            self.inner.min_height_vecs_len(),
+        ]
+        .into_iter()
+        .min()
+        .unwrap()
+    }
+
+    fn reset_state_starting_height(&mut self) {
+        self.starting_height = Some(Height::ZERO);
+    }
+
+    fn import_state(&mut self, starting_height: Height) -> Result<Height> {
+        let starting_height = self
+            .inner
+            .import_state(starting_height, &mut self.state.as_mut().unwrap().inner)?;
+
+        self.starting_height = Some(starting_height);
+
+        if let Some(prev_height) = starting_height.decremented() {
+            self.state.as_mut().unwrap().address_count = *self
+                .height_to_address_count
+                .into_iter()
+                .unwrap_get_inner(prev_height);
+        }
+
+        Ok(starting_height)
+    }
+
+    fn validate_computed_versions(&mut self, base_version: Version) -> Result<()> {
+        self.height_to_address_count
+            .validate_computed_version_or_reset(
+                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.unwrap() > height {
+            return Ok(());
+        }
+
+        self.height_to_address_count.forced_push_at(
+            height,
+            self.state.as_ref().unwrap().address_count.into(),
+            exit,
+        )?;
+
+        self.inner
+            .forced_pushed_at(height, exit, &self.state.as_ref().unwrap().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.as_ref().unwrap().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.as_mut().unwrap().inner)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part1(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> 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, price, 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,
+        price: Option<&price::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,
+    ) -> Result<()> {
+        self.inner.compute_rest_part2(
+            indexer,
+            indexes,
+            price,
+            starting_indexes,
+            market,
+            height_to_supply,
+            dateindex_to_supply,
+            height_to_realized_cap,
+            dateindex_to_realized_cap,
+            exit,
+        )
+    }
+}
+
+impl Deref for Vecs {
+    type Target = common::Vecs;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}

crates/brk_computer/src/stateful/address_cohorts.rs

@@ -0,0 +1,553 @@
+use std::path::Path;
+
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{
+    AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex,
+    Dollars, GroupFilter, Height, Version,
+};
+use derive_deref::{Deref, DerefMut};
+use vecdb::{AnyIterableVec, Database, Exit, Format};
+
+use crate::{
+    Indexes, indexes, market, price,
+    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(
+        db: &Database,
+        version: Version,
+        format: Format,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        states_path: &Path,
+    ) -> Result<Self> {
+        Ok(Self(
+            AddressGroups {
+                amount_range: ByAmountRange {
+                    _0sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_with_0sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _1sat_to_10sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1sat_under_10sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _10sats_to_100sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10sats_under_100sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _100sats_to_1k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_100sats_under_1k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _1k_sats_to_10k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1k_sats_under_10k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _10k_sats_to_100k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10k_sats_under_100k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _100k_sats_to_1m_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_100k_sats_under_1m_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _1m_sats_to_10m_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1m_sats_under_10m_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _10m_sats_to_1btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10m_sats_under_1btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _1btc_to_10btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1btc_under_10btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _10btc_to_100btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10btc_under_100btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _100btc_to_1k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_100btc_under_1k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _1k_btc_to_10k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1k_btc_under_10k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _10k_btc_to_100k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10k_btc_under_100k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                    _100k_btc_or_more: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_100k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        Some(states_path),
+                        true,
+                    )?,
+                },
+                lt_amount: ByLowerThanAmount {
+                    _10sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_10sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _100sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_100sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_1k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_10k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _100k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_100k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1m_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_1m_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10m_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_10m_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_1btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_10btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _100btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_100btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_1k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_10k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _100k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_under_100k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                },
+                ge_amount: ByGreatEqualAmount {
+                    _1sat: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1sat"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _100sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_100sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _100k_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_100k_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1m_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1m_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10m_sats: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10m_sats"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _100btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_100btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _1k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_1k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        true,
+                    )?,
+                    _10k_btc: address_cohort::Vecs::forced_import(
+                        db,
+                        Some("addrs_above_10k_btc"),
+                        format,
+                        version + VERSION + Version::ZERO,
+                        indexes,
+                        price,
+                        None,
+                        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_iter()
+        .flatten()
+        .try_for_each(|(vecs, stateful)| {
+            vecs.compute_from_stateful(starting_indexes, &stateful, exit)
+        })
+    }
+
+    pub fn compute_rest_part1(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.as_mut_vecs().into_iter().try_for_each(|(_, v)| {
+            v.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute_rest_part2(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::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,
+    ) -> Result<()> {
+        self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| {
+            v.into_iter().try_for_each(|(_, v)| {
+                v.compute_rest_part2(
+                    indexer,
+                    indexes,
+                    price,
+                    starting_indexes,
+                    market,
+                    height_to_supply,
+                    dateindex_to_supply,
+                    height_to_realized_cap,
+                    dateindex_to_realized_cap,
+                    exit,
+                )
+            })
+        })
+    }
+
+    pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
+        self.as_mut_separate_vecs()
+            .into_iter()
+            .try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))
+    }
+}

crates/brk_computer/src/stateful/addresstype/addresscount.rs

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

crates/brk_computer/src/stateful/addresstype/height_to_addresscount.rs

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

crates/brk_computer/src/stateful/addresstype/height_to_vec.rs

@@ -0,0 +1,9 @@
+use std::collections::BTreeMap;
+
+use brk_structs::Height;
+use derive_deref::{Deref, DerefMut};
+
+use crate::stateful::AddressTypeToVec;
+
+#[derive(Debug, Default, Deref, DerefMut)]
+pub struct HeightToAddressTypeToVec<T>(pub BTreeMap<Height, AddressTypeToVec<T>>);

crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs

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

crates/brk_computer/src/stateful/addresstype/mod.rs

@@ -0,0 +1,13 @@
+mod addresscount;
+mod height_to_addresscount;
+mod height_to_vec;
+mod indexes_to_addresscount;
+mod typeindex_tree;
+mod vec;
+
+pub use addresscount::*;
+pub use height_to_addresscount::*;
+pub use height_to_vec::*;
+pub use indexes_to_addresscount::*;
+pub use typeindex_tree::*;
+pub use vec::*;

crates/brk_computer/src/stateful/addresstype/typeindex_tree.rs

@@ -0,0 +1,45 @@
+use std::{collections::BTreeMap, mem};
+
+use brk_structs::{ByAddressType, TypeIndex};
+use derive_deref::{Deref, DerefMut};
+
+#[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 {
+        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);
+        self
+    }
+
+    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);
+        }
+    }
+}
+
+impl<T> Default for AddressTypeToTypeIndexTree<T> {
+    fn default() -> Self {
+        Self(ByAddressType {
+            p2pk65: BTreeMap::default(),
+            p2pk33: BTreeMap::default(),
+            p2pkh: BTreeMap::default(),
+            p2sh: BTreeMap::default(),
+            p2wpkh: BTreeMap::default(),
+            p2wsh: BTreeMap::default(),
+            p2tr: BTreeMap::default(),
+            p2a: BTreeMap::default(),
+        })
+    }
+}

crates/brk_computer/src/stateful/addresstype/vec.rs

@@ -0,0 +1,56 @@
+use std::mem;
+
+use brk_structs::ByAddressType;
+use derive_deref::{Deref, DerefMut};
+
+#[derive(Debug, Deref, DerefMut)]
+pub struct AddressTypeToVec<T>(ByAddressType<Vec<T>>);
+
+impl<T> AddressTypeToVec<T> {
+    pub fn merge(mut self, mut other: Self) -> 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);
+        self
+    }
+
+    pub fn merge_mut(&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);
+        }
+    }
+}
+
+impl<T> Default for AddressTypeToVec<T> {
+    fn default() -> Self {
+        Self(ByAddressType {
+            p2pk65: vec![],
+            p2pk33: vec![],
+            p2pkh: vec![],
+            p2sh: vec![],
+            p2wpkh: vec![],
+            p2wsh: vec![],
+            p2tr: vec![],
+            p2a: vec![],
+        })
+    }
+}

crates/brk_computer/src/stateful/range_map.rs

@@ -0,0 +1,49 @@
+use std::collections::BTreeMap;
+
+use vecdb::{CompressedVec, RawVec, StoredCompressed, StoredIndex, StoredRaw};
+
+#[derive(Debug)]
+pub struct RangeMap<I, T>(BTreeMap<I, T>);
+
+impl<I, T> RangeMap<I, T>
+where
+    I: StoredIndex,
+    T: StoredIndex,
+{
+    pub fn get(&self, key: I) -> Option<&T> {
+        self.0.range(..=key).next_back().map(|(&min, value)| {
+            if min > key {
+                unreachable!()
+            }
+            value
+        })
+    }
+}
+
+impl<I, T> From<&RawVec<I, T>> for RangeMap<T, I>
+where
+    I: StoredIndex,
+    T: StoredIndex + StoredRaw,
+{
+    fn from(vec: &RawVec<I, T>) -> Self {
+        Self(
+            vec.into_iter()
+                .map(|(i, v)| (v.into_owned(), i))
+                .collect::<BTreeMap<_, _>>(),
+        )
+    }
+}
+
+impl<I, T> From<&CompressedVec<I, T>> for RangeMap<T, I>
+where
+    I: StoredIndex,
+    T: StoredIndex + StoredCompressed,
+{
+    fn from(vec: &CompressedVec<I, T>) -> Self {
+        Self(
+            vec.into_iter()
+                .map(|(i, v)| (v.into_owned(), i))
+                .collect::<BTreeMap<_, _>>(),
+        )
+    }
+}

crates/brk_computer/src/stateful/trait.rs

@@ -0,0 +1,64 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
+use vecdb::{AnyCollectableVec, AnyIterableVec, Exit};
+
+use crate::{Indexes, indexes, market, price};
+
+pub trait DynCohortVecs: Send + Sync {
+    fn min_height_vecs_len(&self) -> usize;
+    fn reset_state_starting_height(&mut self);
+
+    fn import_state(&mut self, starting_height: Height) -> Result<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,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> 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,
+        price: Option<&price::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,
+    ) -> Result<()>;
+}

crates/brk_computer/src/stateful/utxo_cohort.rs

@@ -0,0 +1,188 @@
+use std::{ops::Deref, path::Path};
+
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
+use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, Format};
+
+use crate::{
+    Indexes, UTXOCohortState, indexes, market, price,
+    stateful::{
+        common,
+        r#trait::{CohortVecs, DynCohortVecs},
+    },
+};
+
+#[derive(Clone)]
+pub struct Vecs {
+    state_starting_height: Option<Height>,
+
+    pub state: Option<UTXOCohortState>,
+
+    inner: common::Vecs,
+}
+
+impl Vecs {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        db: &Database,
+        cohort_name: Option<&str>,
+        format: Format,
+        version: Version,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        states_path: Option<&Path>,
+        compute_relative_to_all: bool,
+        ratio_extended: bool,
+        compute_adjusted: bool,
+    ) -> Result<Self> {
+        let compute_dollars = price.is_some();
+
+        Ok(Self {
+            state_starting_height: None,
+
+            state: states_path.map(|states_path| {
+                UTXOCohortState::new(
+                    states_path,
+                    cohort_name.unwrap_or_default(),
+                    compute_dollars,
+                )
+            }),
+
+            inner: common::Vecs::forced_import(
+                db,
+                cohort_name,
+                format,
+                version,
+                indexes,
+                price,
+                compute_relative_to_all,
+                ratio_extended,
+                compute_adjusted,
+            )?,
+        })
+    }
+}
+
+impl DynCohortVecs for Vecs {
+    fn min_height_vecs_len(&self) -> usize {
+        self.inner.min_height_vecs_len()
+    }
+
+    fn reset_state_starting_height(&mut self) {
+        self.state_starting_height = Some(Height::ZERO);
+    }
+
+    fn import_state(&mut self, starting_height: Height) -> Result<Height> {
+        let starting_height = self
+            .inner
+            .import_state(starting_height, self.state.as_mut().unwrap())?;
+
+        self.state_starting_height = Some(starting_height);
+
+        Ok(starting_height)
+    }
+
+    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.state_starting_height.unwrap() > height {
+            return Ok(());
+        }
+
+        self.inner
+            .forced_pushed_at(height, exit, self.state.as_ref().unwrap())
+    }
+
+    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.as_mut().unwrap(),
+        )
+    }
+
+    fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
+        self.inner
+            .safe_flush_stateful_vecs(height, exit, self.state.as_mut().unwrap())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compute_rest_part1(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.inner
+            .compute_rest_part1(indexer, indexes, price, 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,
+        price: Option<&price::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,
+    ) -> Result<()> {
+        self.inner.compute_rest_part2(
+            indexer,
+            indexes,
+            price,
+            starting_indexes,
+            market,
+            height_to_supply,
+            dateindex_to_supply,
+            height_to_realized_cap,
+            dateindex_to_realized_cap,
+            exit,
+        )
+    }
+}
+
+impl Deref for Vecs {
+    type Target = common::Vecs;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}

crates/brk_computer/src/stateful/withaddressdatasource.rs

@@ -0,0 +1,54 @@
+use brk_structs::{EmptyAddressData, EmptyAddressIndex, LoadedAddressData, LoadedAddressIndex};
+
+#[derive(Debug)]
+pub enum WithAddressDataSource<T> {
+    New(T),
+    FromLoadedAddressDataVec((LoadedAddressIndex, T)),
+    FromEmptyAddressDataVec((EmptyAddressIndex, T)),
+}
+
+impl<T> WithAddressDataSource<T> {
+    pub fn is_new(&self) -> bool {
+        matches!(self, Self::New(_))
+    }
+
+    pub fn is_from_emptyaddressdata(&self) -> bool {
+        matches!(self, Self::FromEmptyAddressDataVec(_))
+    }
+
+    pub fn deref_mut(&mut self) -> &mut T {
+        match self {
+            Self::New(v) => v,
+            Self::FromLoadedAddressDataVec((_, v)) => v,
+            Self::FromEmptyAddressDataVec((_, v)) => v,
+        }
+    }
+}
+
+impl From<WithAddressDataSource<EmptyAddressData>> for WithAddressDataSource<LoadedAddressData> {
+    fn from(value: WithAddressDataSource<EmptyAddressData>) -> Self {
+        match value {
+            WithAddressDataSource::New(v) => Self::New(v.into()),
+            WithAddressDataSource::FromLoadedAddressDataVec((i, v)) => {
+                Self::FromLoadedAddressDataVec((i, v.into()))
+            }
+            WithAddressDataSource::FromEmptyAddressDataVec((i, v)) => {
+                Self::FromEmptyAddressDataVec((i, v.into()))
+            }
+        }
+    }
+}
+
+impl From<WithAddressDataSource<LoadedAddressData>> for WithAddressDataSource<EmptyAddressData> {
+    fn from(value: WithAddressDataSource<LoadedAddressData>) -> Self {
+        match value {
+            WithAddressDataSource::New(v) => Self::New(v.into()),
+            WithAddressDataSource::FromLoadedAddressDataVec((i, v)) => {
+                Self::FromLoadedAddressDataVec((i, v.into()))
+            }
+            WithAddressDataSource::FromEmptyAddressDataVec((i, v)) => {
+                Self::FromEmptyAddressDataVec((i, v.into()))
+            }
+        }
+    }
+}

crates/brk_computer/src/states/block.rs

@@ -1,13 +1,17 @@
 use std::ops::{Add, AddAssign, SubAssign};
 
-use brk_core::{Dollars, Timestamp};
+use brk_structs::{Dollars, Timestamp};
+use serde::Serialize;
 
 use super::SupplyState;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct BlockState {
+    #[serde(flatten)]
     pub supply: SupplyState,
+    #[serde(skip)]
     pub price: Option<Dollars>,
+    #[serde(skip)]
     pub timestamp: Timestamp,
 }
 

crates/brk_computer/src/states/cohort.rs

@@ -1,27 +0,0 @@
-use brk_core::Dollars;
-
-use super::{RealizedState, SupplyState};
-
-// Vecs ? probably
-#[derive(Debug, Default, Clone)]
-pub struct CohortState {
-    pub supply: SupplyState,
-    pub realized: Option<RealizedState>,
-    // pub price_to_amount: PriceToValue<Amount>, save it not rounded in fjall
-}
-
-impl CohortState {
-    pub fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
-        self.supply += supply_state;
-        if let Some(realized) = self.realized.as_mut() {
-            realized.increment(supply_state, price.unwrap());
-        }
-    }
-
-    pub fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
-        self.supply -= supply_state;
-        if let Some(realized) = self.realized.as_mut() {
-            realized.decrement(supply_state, price.unwrap());
-        }
-    }
-}

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

@@ -0,0 +1,122 @@
+use std::path::Path;
+
+use brk_error::Result;
+use brk_structs::{Dollars, Height, LoadedAddressData, Sats};
+
+use crate::SupplyState;
+
+use super::CohortState;
+
+#[derive(Clone)]
+pub struct AddressCohortState {
+    pub address_count: u64,
+    pub inner: CohortState,
+}
+
+impl AddressCohortState {
+    pub fn new(path: &Path, name: &str, compute_dollars: bool) -> Self {
+        Self {
+            address_count: 0,
+            inner: CohortState::new(path, name, compute_dollars),
+        }
+    }
+
+    pub fn reset_price_to_amount_if_needed(&mut self) -> Result<()> {
+        self.inner.reset_price_to_amount_if_needed()
+    }
+
+    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 LoadedAddressData,
+        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 u64,
+            value: addressdata.amount(),
+        };
+
+        addressdata.send(value, prev_price)?;
+
+        let supply_state = SupplyState {
+            utxos: addressdata.outputs_len as u64,
+            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 LoadedAddressData,
+        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 u64,
+            value: address_data.amount(),
+        };
+
+        address_data.receive(value, price);
+
+        let supply_state = SupplyState {
+            utxos: address_data.outputs_len as u64,
+            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: &LoadedAddressData) {
+        self.address_count += 1;
+        self.inner.increment_(
+            &addressdata.into(),
+            addressdata.realized_cap,
+            addressdata.realized_price(),
+        );
+    }
+
+    pub fn subtract(&mut self, addressdata: &LoadedAddressData) {
+        self.address_count = self.address_count.checked_sub(1).unwrap();
+        self.inner.decrement_(
+            &addressdata.into(),
+            addressdata.realized_cap,
+            addressdata.realized_price(),
+        );
+    }
+
+    pub fn commit(&mut self, height: Height) -> Result<()> {
+        self.inner.commit(height)
+    }
+}

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

@@ -0,0 +1,317 @@
+use std::{cmp::Ordering, path::Path};
+
+use brk_error::Result;
+use brk_structs::{CheckedSub, Dollars, Height, Sats};
+
+use crate::{PriceToAmount, RealizedState, SupplyState, UnrealizedState};
+
+#[derive(Clone)]
+pub struct CohortState {
+    pub supply: SupplyState,
+
+    pub realized: Option<RealizedState>,
+    pub satblocks_destroyed: Sats,
+    pub satdays_destroyed: Sats,
+
+    price_to_amount: Option<PriceToAmount>,
+}
+
+impl CohortState {
+    pub fn new(path: &Path, name: &str, compute_dollars: bool) -> Self {
+        Self {
+            supply: SupplyState::default(),
+            realized: compute_dollars.then_some(RealizedState::NAN),
+            satblocks_destroyed: Sats::ZERO,
+            satdays_destroyed: Sats::ZERO,
+            price_to_amount: compute_dollars.then_some(PriceToAmount::create(path, name)),
+        }
+    }
+
+    pub fn import_at_or_before(&mut self, height: Height) -> Result<Height> {
+        if let Some(price_to_amount) = self.price_to_amount.as_mut() {
+            price_to_amount.import_at_or_before(height)
+        } else {
+            Ok(height)
+        }
+    }
+
+    pub fn reset_price_to_amount_if_needed(&mut self) -> Result<()> {
+        if let Some(price_to_amount) = self.price_to_amount.as_mut() {
+            price_to_amount.clean()?;
+            price_to_amount.init();
+        }
+        Ok(())
+    }
+
+    pub fn price_to_amount_first_key_value(&self) -> Option<(&Dollars, &Sats)> {
+        self.price_to_amount.as_ref().unwrap().first_key_value()
+    }
+
+    pub fn price_to_amount_last_key_value(&self) -> Option<(&Dollars, &Sats)> {
+        self.price_to_amount.as_ref().unwrap().last_key_value()
+    }
+
+    pub fn reset_single_iteration_values(&mut self) {
+        self.satdays_destroyed = Sats::ZERO;
+        self.satblocks_destroyed = Sats::ZERO;
+        if let Some(realized) = self.realized.as_mut() {
+            realized.reset_single_iteration_values();
+        }
+    }
+
+    pub fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.supply += supply_state;
+
+        if supply_state.value > Sats::ZERO
+            && let Some(realized) = self.realized.as_mut()
+        {
+            let price = price.unwrap();
+            realized.increment(supply_state, price);
+            self.price_to_amount
+                .as_mut()
+                .unwrap()
+                .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
+            && let Some(realized) = self.realized.as_mut()
+        {
+            realized.increment_(realized_cap);
+            self.price_to_amount
+                .as_mut()
+                .unwrap()
+                .increment(realized_price, supply_state);
+        }
+    }
+
+    pub fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
+        self.supply -= supply_state;
+
+        if supply_state.value > Sats::ZERO
+            && let Some(realized) = self.realized.as_mut()
+        {
+            let price = price.unwrap();
+            realized.decrement(supply_state, price);
+            self.price_to_amount
+                .as_mut()
+                .unwrap()
+                .decrement(price, supply_state);
+        }
+    }
+
+    pub fn decrement_(
+        &mut self,
+        supply_state: &SupplyState,
+        realized_cap: Dollars,
+        realized_price: Dollars,
+    ) {
+        self.supply -= supply_state;
+
+        if supply_state.value > Sats::ZERO
+            && let Some(realized) = self.realized.as_mut()
+        {
+            realized.decrement_(realized_cap);
+            self.price_to_amount
+                .as_mut()
+                .unwrap()
+                .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
+            && let Some(realized) = self.realized.as_mut()
+        {
+            let price = price.unwrap();
+            realized.receive(supply_state, price);
+
+            if let Some((price, supply)) = price_to_amount_increment
+                && supply.value.is_not_zero()
+            {
+                self.price_to_amount
+                    .as_mut()
+                    .unwrap()
+                    .increment(price, supply);
+            }
+
+            if let Some((price, supply)) = price_to_amount_decrement
+                && supply.value.is_not_zero()
+            {
+                self.price_to_amount
+                    .as_mut()
+                    .unwrap()
+                    .decrement(price, supply);
+            }
+        }
+    }
+
+    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,
+    ) {
+        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 {
+            self.satblocks_destroyed += supply_state.value * blocks_old;
+
+            self.satdays_destroyed +=
+                Sats::from((u64::from(supply_state.value) as f64 * days_old).floor() as u64);
+
+            if let Some(realized) = self.realized.as_mut() {
+                let current_price = current_price.unwrap();
+                let prev_price = prev_price.unwrap();
+                realized.send(supply_state, current_price, prev_price, older_than_hour);
+                if let Some((price, supply)) = price_to_amount_increment
+                    && supply.value.is_not_zero()
+                {
+                    self.price_to_amount
+                        .as_mut()
+                        .unwrap()
+                        .increment(price, supply);
+                }
+                if let Some((price, supply)) = price_to_amount_decrement
+                    && supply.value.is_not_zero()
+                {
+                    self.price_to_amount
+                        .as_mut()
+                        .unwrap()
+                        .decrement(price, supply);
+                }
+            }
+        }
+    }
+
+    pub fn compute_unrealized_states(
+        &self,
+        height_price: Dollars,
+        date_price: Option<Dollars>,
+    ) -> (UnrealizedState, Option<UnrealizedState>) {
+        if self.price_to_amount.as_ref().unwrap().is_empty() {
+            return (
+                UnrealizedState::NAN,
+                date_price.map(|_| UnrealizedState::NAN),
+            );
+        }
+
+        let mut height_unrealized_state = UnrealizedState::ZERO;
+        let mut date_unrealized_state = date_price.map(|_| UnrealizedState::ZERO);
+
+        let update_state =
+            |price: Dollars, current_price: Dollars, sats: Sats, state: &mut UnrealizedState| {
+                match price.cmp(&current_price) {
+                    Ordering::Less => {
+                        state.supply_in_profit += sats;
+                        if price > Dollars::ZERO && current_price > Dollars::ZERO {
+                            let diff = current_price.checked_sub(price).unwrap();
+                            // Add back once in a while to verify, but generally not needed
+                            // if diff <= Dollars::ZERO {
+                            //     dbg!(price, current_price, diff, sats);
+                            //     panic!();
+                            // }
+                            state.unrealized_profit += diff * sats;
+                        }
+                    }
+                    Ordering::Greater => {
+                        state.supply_in_loss += sats;
+                        if price > Dollars::ZERO && current_price > Dollars::ZERO {
+                            let diff = price.checked_sub(current_price).unwrap();
+                            // Add back once in a while to verify, but generally not needed
+                            // if diff <= Dollars::ZERO {
+                            //     dbg!(price, current_price, diff, sats);
+                            //     panic!();
+                            // }
+                            state.unrealized_loss += diff * sats;
+                        }
+                    }
+                    Ordering::Equal => {
+                        state.supply_even += sats;
+                    }
+                }
+            };
+
+        self.price_to_amount
+            .as_ref()
+            .unwrap()
+            .iter()
+            .for_each(|(&price, &sats)| {
+                update_state(price, height_price, sats, &mut height_unrealized_state);
+
+                if let Some(date_price) = date_price {
+                    update_state(
+                        price,
+                        date_price,
+                        sats,
+                        date_unrealized_state.as_mut().unwrap(),
+                    )
+                }
+            });
+
+        (height_unrealized_state, date_unrealized_state)
+    }
+
+    pub fn commit(&mut self, height: Height) -> Result<()> {
+        if let Some(price_to_amount) = self.price_to_amount.as_mut() {
+            price_to_amount.flush(height)?;
+        }
+        Ok(())
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+use std::path::Path;
+
+use brk_error::Result;
+use derive_deref::{Deref, DerefMut};
+
+use super::CohortState;
+
+#[derive(Clone, Deref, DerefMut)]
+pub struct UTXOCohortState(CohortState);
+
+impl UTXOCohortState {
+    pub fn new(path: &Path, name: &str, compute_dollars: bool) -> Self {
+        Self(CohortState::new(path, name, compute_dollars))
+    }
+
+    pub fn reset_price_to_amount_if_needed(&mut self) -> Result<()> {
+        self.0.reset_price_to_amount_if_needed()
+    }
+}

crates/brk_computer/src/states/hot.rs

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

crates/brk_computer/src/states/mod.rs

@@ -1,15 +1,15 @@
 mod block;
-mod cohort;
-mod outputs;
+mod cohorts;
+mod price_to_amount;
 mod realized;
-// mod hot;
 mod supply;
 mod transacted;
+mod unrealized;
 
 pub use block::*;
-pub use cohort::*;
-pub use outputs::*;
+pub use cohorts::*;
+pub use price_to_amount::*;
 pub use realized::*;
-// pub use hot::*;
 pub use supply::*;
 pub use transacted::*;
+pub use unrealized::*;

crates/brk_computer/src/states/outputs/by_from.rs

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

crates/brk_computer/src/states/outputs/by_range.rs

@@ -1,74 +0,0 @@
-use super::OutputFilter;
-
-#[derive(Default, Clone)]
-pub struct OutputsByRange<T> {
-    pub _1d_to_1w: T,
-    pub _1w_to_1m: T,
-    pub _1m_to_3m: T,
-    pub _3m_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_7y: T,
-    pub _7y_to_10y: T,
-    pub _10y_to_15y: T,
-}
-
-impl<T> From<OutputsByRange<T>> for OutputsByRange<(OutputFilter, T)> {
-    fn from(value: OutputsByRange<T>) -> Self {
-        Self {
-            _1d_to_1w: (OutputFilter::Range(1..7), value._1d_to_1w),
-            _1w_to_1m: (OutputFilter::Range(7..30), value._1w_to_1m),
-            _1m_to_3m: (OutputFilter::Range(30..3 * 30), value._1m_to_3m),
-            _3m_to_6m: (OutputFilter::Range(3 * 30..6 * 30), value._3m_to_6m),
-            _6m_to_1y: (OutputFilter::Range(6 * 30..365), value._6m_to_1y),
-            _1y_to_2y: (OutputFilter::Range(365..2 * 365), value._1y_to_2y),
-            _2y_to_3y: (OutputFilter::Range(2 * 365..3 * 365), value._2y_to_3y),
-            _3y_to_4y: (OutputFilter::Range(3 * 365..4 * 365), value._3y_to_4y),
-            _4y_to_5y: (OutputFilter::Range(4 * 365..5 * 365), value._4y_to_5y),
-            _5y_to_7y: (OutputFilter::Range(5 * 365..7 * 365), value._5y_to_7y),
-            _7y_to_10y: (OutputFilter::Range(7 * 365..10 * 365), value._7y_to_10y),
-            _10y_to_15y: (OutputFilter::Range(10 * 365..15 * 365), value._10y_to_15y),
-        }
-    }
-}
-
-impl<T> OutputsByRange<T> {
-    pub fn as_mut_vec(&mut self) -> [&mut T; 12] {
-        [
-            &mut self._1d_to_1w,
-            &mut self._1w_to_1m,
-            &mut self._1m_to_3m,
-            &mut self._3m_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_7y,
-            &mut self._7y_to_10y,
-            &mut self._10y_to_15y,
-        ]
-    }
-}
-
-impl<T> OutputsByRange<(OutputFilter, T)> {
-    pub fn vecs(&self) -> [&T; 12] {
-        [
-            &self._1d_to_1w.1,
-            &self._1w_to_1m.1,
-            &self._1m_to_3m.1,
-            &self._3m_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_7y.1,
-            &self._7y_to_10y.1,
-            &self._10y_to_15y.1,
-        ]
-    }
-}

crates/brk_computer/src/states/outputs/by_size.rs

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