release: v0.0.69

vec: undo storing file in struct, can overwhelm system
release: v0.0.68
2026-06-26 14:14:30 -07:00 · 2025-06-24 13:23:14 +02:00 · 2025-06-24 13:20:44 +02:00 · 2025-06-24 12:19:07 +02:00 · 2025-06-24 12:18:49 +02:00 · 2025-06-24 11:57:25 +02:00
419 changed files with 41984 additions and 19725 deletions
@@ -1,2 +0,0 @@
-[build]
-rustflags = ["-C", "target-cpu=native"]
@@ -3,36 +3,18 @@

 # Builds
 target
+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
@@ -1,44 +1,17 @@
 <!--
 # v0.X.Y | WIP
-![Image of the kibo Web App version 0.X.Y](https://github.com/kibo-money/kibo/blob/main/_assets/v0.X.Y.jpg)
+![Image of the kibo Web App version 0.X.Y](https://github.com/bitcoinresearchkit/brk/blob/main/assets/v0.X.Y.jpg)
 -->

-# v0.6.0 | WIP | A new beginning
+# v0.X.0 | WIP | A new beginning

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

- Completely redesign the back-end
+Full rewrite

- Merged parser and server crates into a single project (and thus executable), so now both will run at the same time with a single `cargo run -r` [#7392982](https://github.com/kibo-money/kibo/commit/7392982824c2db94bcd57251fd41986117c29a23)
- Added `--no-server` and `--no-parser` to disable each if needed
- Improved executable parameters
- Started using `log` and `env_logger` crates instead of custom code [#7392982](https://github.com/kibo-money/kibo/commit/7392982824c2db94bcd57251fd41986117c29a23)
- Improved logs
- Fixed input being unfocused right after being focused in Brave browser [#9a9ae61](https://github.com/kibo-money/kibo/commit/9a9ae614d07b54c08b7e9c0e2aefe3b52fdb93c5)
+# [kibo-v0.5.0](https://github.com/bitcoinresearchkit/brk/tree/eea56d394bf92c62c81da8b78b8c47ea730683f5) | [873199](https://mempool.space/block/0000000000000000000270925aa6a565be92e13164565a3f7994ca1966e48050) - 2024/12/04

- Reworked server's API code [#6ab0f46]( https://github.com/kibo-money/kibo/commit/6ab0f463119a902a1b7ca9691b54f61543bb8f2f)
-  - New route format: `/api/date-to-realized-price` is now `/api/realized-price?kind=date`
-  - Added status and timing to logs
- Updated website packages
- Added API support for datasets by timestamp (by merging any dataset by height with the height to timestamp dataset and so it still uses heights as chunk ids) [#ca00f3f](https://github.com/kibo-money/kibo/commit/ca00f3f71526f0c5c16021024fec7e5c6e47221c)
-  - `/api/realized-price?kind=t`
-  - `/api/realized-price?kind=timestamp&chunk=860000`
- Created separate crate for indexing called `bindex`
- Created a crate a storage engine specialized in storing datasets that have indexes as keys and thus can be represented by an array/vec called `storable-vec`
- Removed the need for the `-txindex=1` parameter when starting your Bitcoin Core node as kibo has its own indexes now
-
-## Git
-
-Added git tags for each version though Markdown won't display formatted on Github so left the default text
-
-## Deprecated
-
-Moved Sanakirja database wrapper to its own crate (`snkrj`) and added a robust auto defragmentation to improve disk usage without the need for user's intervention.
-Since it's not used anymore it will moved out of the repository relatively soon.
-
-# [kibo-v0.5.0](https://github.com/kibo-money/kibo/tree/eea56d394bf92c62c81da8b78b8c47ea730683f5) | [873199](https://mempool.space/block/0000000000000000000270925aa6a565be92e13164565a3f7994ca1966e48050) - 2024/12/04
-
-![Image of the kibo Web App version 0.5.0](https://github.com/kibo-money/kibo/blob/main/_assets/v0.5.0.jpg)
+![Image of the kibo Web App version 0.5.0](https://github.com/bitcoinresearchkit/brk/blob/main/assets/kibo-v0.5.0.jpg)

 ## Datasets

@@ -103,9 +76,9 @@ Since it's not used anymore it will moved out of the repository relatively soon.

 - Moved back to this repo

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

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

 ## Brand

@@ -140,9 +113,9 @@ Since it's not used anymore it will moved out of the repository relatively soon.
 - Added serving of the website
 - Improved `Cache-Control` behavior

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

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

 ## Parser

@@ -219,9 +192,9 @@ Since it's not used anymore it will moved out of the repository relatively soon.
  - Only run with a watcher if `cargo watch` is available
  - Removed id_to_path file in favor for only `paths.d.ts` in `app/src/types`

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

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

 ## App

@@ -255,9 +228,9 @@ Since it's not used anymore it will moved out of the repository relatively soon.

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

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

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

 ## Parser

@@ -305,10 +278,10 @@ Since it's not used anymore it will moved out of the repository relatively soon.

 - Deleted old price datasets and their backups

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

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

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

-![Image of the Satonomics Web App version 0.0.X](https://github.com/kibo-money/kibo/blob/main/_assets/v0.0.X.jpg)
+![Image of the Satonomics Web App version 0.0.X](https://github.com/bitcoinresearchkit/brk/blob/main/assets/satonomics-v0.0.1.jpg)
@@ -4,7 +4,8 @@ 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.31"
+package.version = "0.0.69"
+package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"

 [profile.release]
@@ -16,33 +17,46 @@ panic = "abort"
 inherits = "release"

 [workspace.dependencies]
-axum = "0.8.3"
-bitcoin = { version = "0.32.5", features = ["serde"] }
+arc-swap = "1.7.1"
+axum = "0.8.4"
+bincode = { version = "2.0.1", features = ["serde"] }
+bitcoin = { version = "0.32.6", features = ["serde"] }
 bitcoincore-rpc = "0.19.0"
-brk_cli = { version = "0", path = "crates/brk_cli" }
-brk_computer = { version = "0", path = "crates/brk_computer" }
-brk_core = { version = "0", path = "crates/brk_core" }
-brk_exit = { version = "0", path = "crates/brk_exit" }
-brk_fetcher = { version = "0", path = "crates/brk_fetcher" }
-brk_indexer = { version = "0", path = "crates/brk_indexer" }
-brk_logger = { version = "0", path = "crates/brk_logger" }
-brk_parser = { version = "0", path = "crates/brk_parser" }
-brk_query = { version = "0", path = "crates/brk_query" }
-brk_server = { version = "0", path = "crates/brk_server" }
-brk_vec = { version = "0", path = "crates/brk_vec" }
-byteview = "0.6.1"
-clap = { version = "4.5.37", features = ["derive", "string"] }
-color-eyre = "0.6.3"
+brk_bundler = { version = "0.0.69", path = "crates/brk_bundler" }
+brk_cli = { version = "0.0.69", path = "crates/brk_cli" }
+brk_computer = { version = "0.0.69", path = "crates/brk_computer" }
+brk_core = { version = "0.0.69", path = "crates/brk_core" }
+brk_exit = { version = "0.0.69", path = "crates/brk_exit" }
+brk_fetcher = { version = "0.0.69", path = "crates/brk_fetcher" }
+brk_indexer = { version = "0.0.69", path = "crates/brk_indexer" }
+brk_interface = { version = "0.0.69", path = "crates/brk_interface" }
+brk_logger = { version = "0.0.69", path = "crates/brk_logger" }
+brk_mcp = { version = "0.0.69", path = "crates/brk_mcp" }
+brk_parser = { version = "0.0.69", path = "crates/brk_parser" }
+brk_rmcp = { version = "0.1.7", features = ["transport-streamable-http-server", "transport-worker"]}
+brk_server = { version = "0.0.69", path = "crates/brk_server" }
+brk_state = { version = "0.0.69", path = "crates/brk_state" }
+brk_store = { version = "0.0.69", path = "crates/brk_store" }
+brk_vec = { version = "0.0.69", path = "crates/brk_vec" }
+byteview = "=0.6.1"
+clap = { version = "4.5.40", features = ["string"] }
+clap_derive = "4.5.40"
+color-eyre = "0.6.5"
 derive_deref = "1.1.1"
-fjall = "2.9.0"
-jiff = "0.2.10"
+fjall = "2.11.1"
+jiff = "0.2.15"
 log = { version = "0.4.27" }
 minreq = { version = "2.13.4", features = ["https", "serde_json"] }
 rayon = "1.10.0"
-serde = { version = "1.0.219", features = ["derive"] }
+schemars = "1.0.0"
+serde = { version = "1.0.219" }
+serde_bytes = "0.11.17"
+serde_derive = "1.0.219"
 serde_json = { version = "1.0.140", features = ["float_roundtrip"] }
-tabled = "0.19.0"
-zerocopy = { version = "0.8.24", features = ["derive"] }
+tabled = "0.20.0"
+tokio = { version = "1.45.1", features = ["rt-multi-thread"] }
+zerocopy = { version = "0.8.26" }
+zerocopy-derive = "0.8.26"

 [workspace.metadata.release]
 shared-version = true
@@ -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
@@ -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>
@@ -34,28 +31,26 @@
  </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: [kibo.money](https://kibo.money) // [satonomics.xyz](https://satonomics.xyz)
+- **[API](https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#brk-server)** \
+  Researchers and developers are free to use BRK's public API with ![Datasets variant count](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fbitcoinresearchkit.org%2Fapi%2Fvecs%2Fvariant-count&query=%24&style=flat&label=%20&color=white) dataset variants at their disposal. \
+  Just like the website, it's entirely free, with no authentication or rate-limiting.
+- **[AI](https://github.com/bitcoinresearchkit/brk/blob/main/crates/brk_mcp/README.md#brk-mcp)** \
+  LLMs have to possibility to connect to BRK's backend through a [MCP](https://modelcontextprotocol.io/introduction). \
+  It will give them access to the same tools as the API, with no restrictions, and allow you to have your very own data analysts. \
+  One-shot output examples: [Document](https://claude.ai/public/artifacts/71194d29-f965-417c-ba09-fdf0e4ecb1d5) // [Dashboard](https://claude.ai/public/artifacts/beef143f-399a-4ed4-b8bf-c986b776de42) // [Dashboard 2](https://claude.ai/public/artifacts/5430ae49-bb3d-4fc1-ab24-f1e33deb40dc)
 - **[CLI](https://crates.io/crates/brk_cli)** \
-  Node runners are strongly encouraged to try out and self-host their own instance. \
-  A lot of effort has gone into making this as easy as possible. \
-  For more information visit: [`brk_cli`](https://crates.io/crates/brk_cli)
+  Node runners are strongly encouraged to try out and self-host their own instance using BRK's command line interface. \
+  The CLI has multiple cogs available for users to tweak to adapt to all situations with even the possibility for web developers to create their own custom website which could later on be added as an alternative front-end.
 - **[Crates](https://crates.io/crates/brk)** \
  Rust developers have access to a wide range crates, each built upon one another with its own specific purpose, enabling independent use and offering great flexibility.
  PRs are welcome, especially if their goal is to introduce additional datasets.
@@ -67,38 +62,42 @@ In contrast, existing alternatives tend to be either [very costly](https://studi
 ## Crates

 - [`brk`](https://crates.io/crates/brk): Wrapper around all other `brk-*` crates
- [`brk_cli`](https://crates.io/crates/brk_cli): A standalone command line interface to interact with the Bitcoin Research Kit
+- [`brk_cli`](https://crates.io/crates/brk_cli): A command line interface to run a Bitcoin Research Kit instance
 - [`brk_computer`](https://crates.io/crates/brk_computer): A Bitcoin dataset computer, built on top of brk_indexer
 - [`brk_core`](https://crates.io/crates/brk_core): The Core (Structs and Errors) of the Bitcoin Research Kit
 - [`brk_exit`](https://crates.io/crates/brk_exit): An exit blocker built on top of ctrlc
 - [`brk_fetcher`](https://crates.io/crates/brk_fetcher): A Bitcoin price fetcher
 - [`brk_indexer`](https://crates.io/crates/brk_indexer): A Bitcoin Core indexer built on top of brk_parser
- [`brk_logger`](https://crates.io/crates/brk_logger): A clean logger used in the Bitcoin Research Kit.
+- [`brk_logger`](https://crates.io/crates/brk_logger): A clean logger used in the Bitcoin Research Kit
+- [`brk_mcp`](https://crates.io/crates/brk_mcp): A Model Context Protocol (MCP) which gives LLMs access to all available tools in BRK
 - [`brk_parser`](https://crates.io/crates/brk_parser): A very fast Bitcoin Core block parser and iterator built on top of bitcoin-rust
- [`brk_query`](https://crates.io/crates/brk_query): A library that finds requested datasets.
+- [`brk_interface`](https://crates.io/crates/brk_interface): An interface to BRK's engine
 - [`brk_server`](https://crates.io/crates/brk_server): A server that serves Bitcoin data and swappable front-ends, built on top of `brk_indexer`, `brk_fetcher` and `brk_computer`
+- [`brk_state`](https://crates.io/crates/brk_state): Various states used mainly by the computer
+- [`brk_store`](https://crates.io/crates/brk_store): A thin wrapper around [`fjall`](https://crates.io/crates/fjall)
 - [`brk_vec`](https://crates.io/crates/brk_vec): A push-only, truncable, compressable, saveable Vec
+- [`brk_bundler`](https://crates.io/crates/brk_bundler): A thin wrapper around [`rolldown`](https://rolldown.rs/)
+
+## Hosting as a service
+
+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`, `*.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.
-
-## Hosting as a service
-
-*Soon™*
-
-If you'd like to have your own instance hosted for you please contact [hosting@bitcoinresearchkit.org](mailto:hosting@bitcoinresearchkit.org).
-
- 2 separate dedicated servers (1 GB/s each) with different ISPs and Cloudflare integration for enhanced performance and optimal availability
- 99.9% SLA
- Direct communication for feature requests and support
- Updates delivered at your convenience
- 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`
+Heartfelt thanks go out to every donor on [Nostr](https://primal.net/p/npub1jagmm3x39lmwfnrtvxcs9ac7g300y3dusv9lgzhk2e4x5frpxlrqa73v44) and [Geyser.fund](https://geyser.fund/project/brk) whose support has ensured the availability of the [bitcoinresearchkit.org](https://bitcoinresearchkit.org) public instance.

 ## Donate

@@ -3,35 +3,45 @@ name = "brk"
 description.workspace = true
 license.workspace = true
 readme.workspace = true
+homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 version.workspace = true

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

 [dependencies]
+brk_bundler = { workspace = true, optional = true }
 brk_cli = { workspace = true }
 brk_core = { workspace = true, optional = true }
 brk_computer = { workspace = true, optional = true }
@@ -39,9 +49,12 @@ brk_exit = { workspace = true, optional = true }
 brk_fetcher = { workspace = true, optional = true }
 brk_indexer = { workspace = true, optional = true }
 brk_logger = { workspace = true, optional = true }
+brk_mcp = { workspace = true, optional = true }
 brk_parser = { workspace = true, optional = true }
-brk_query = { workspace = true, optional = true }
+brk_interface = { workspace = true, optional = true }
 brk_server = { workspace = true, optional = true }
+brk_state = { workspace = true, optional = true }
+brk_store = { workspace = true, optional = true }
 brk_vec = { workspace = true, optional = true }

 [package.metadata.docs.rs]
@@ -0,0 +1 @@
+fn main() {}
@@ -1,5 +1,12 @@
 #![doc = include_str!(concat!("../", env!("CARGO_PKG_README")))]

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

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

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

 #[cfg(feature = "server")]
 #[doc(inline)]
 pub use brk_server as server;

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

 [dependencies]
+bitcoincore-rpc = { workspace = true }
 brk_computer = { workspace = true }
 brk_core = { workspace = true }
 brk_exit = { workspace = true }
@@ -14,14 +16,15 @@ brk_fetcher = { workspace = true }
 brk_indexer = { workspace = true }
 brk_logger = { workspace = true }
 brk_parser = { workspace = true }
-brk_query = { workspace = true }
 brk_server = { workspace = true }
-clap = { workspace = true, features = ["string"] }
+brk_vec = { workspace = true }
+clap = { workspace = true }
+clap_derive = { workspace = true }
 color-eyre = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true }
-tabled = { workspace = true }
-toml = "0.8.20"
+tokio = { workspace = true }
+toml = "0.8.23"

 [[bin]]
 name = "brk"
@@ -1,12 +1,9 @@
-# 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>
@@ -34,9 +31,11 @@
  </a>
 </p>

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

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

 ## Requirements

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

 ## Download

 ### Binaries

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

 ### Cargo

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

 ## Usage

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

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

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

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

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

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

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

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

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

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

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

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

    let rpc = config.rpc()?;

@@ -26,15 +18,33 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {

    let parser = brk_parser::Parser::new(config.blocksdir(), rpc);

-    let compressed = config.compressed();
+    let format = config.format();

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

-    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), compressed);
-    computer.import_stores(&indexer)?;
-    computer.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 mut computer = Computer::forced_import(
+        &config.outputsdir(),
+        &indexer,
+        config.computation(),
+        config.fetcher(),
+        format,
+    )?;

    tokio::runtime::Builder::new_multi_thread()
        .enable_all()
@@ -46,8 +56,10 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {

                let server = Server::new(served_indexer, served_computer, config.website())?;

+                let watch = config.watch();
+                let mcp = config.mcp();
                let opt = Some(tokio::spawn(async move {
-                    server.serve().await.unwrap();
+                    server.serve(watch, mcp).await.unwrap();
                }));

                sleep(Duration::from_secs(1));
@@ -58,22 +70,6 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
            };

            if config.process() {
-                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(())
-                };
-
                loop {
                    wait_for_synced_node()?;

@@ -81,7 +77,8 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {

                    info!("{} blocks found.", block_count + 1);

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

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

@@ -104,341 +101,3 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
            Ok(())
        })
 }
-
-#[derive(Parser, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
-pub struct RunConfig {
-    /// Bitcoin main directory path, defaults: ~/.bitcoin, ~/Library/Application\ Support/Bitcoin, saved
-    #[arg(long, value_name = "PATH")]
-    bitcoindir: Option<String>,
-
-    /// Bitcoin blocks directory path, default: --bitcoindir/blocks, saved
-    #[arg(long, value_name = "PATH")]
-    blocksdir: Option<String>,
-
-    /// Bitcoin Research Kit outputs directory path, default: ~/.brk, saved
-    #[arg(long, value_name = "PATH")]
-    brkdir: Option<String>,
-
-    /// Executed by the runner, default: all, saved
-    #[arg(short, long)]
-    mode: Option<Mode>,
-
-    /// 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")]
-    fetch: Option<bool>,
-
-    /// Website served by the server (if active), default: kibo.money, saved
-    #[arg(short, long)]
-    website: Option<Website>,
-
-    /// Bitcoin RPC ip, default: localhost, saved
-    #[arg(long, value_name = "IP")]
-    rpcconnect: Option<String>,
-
-    /// Bitcoin RPC port, default: 8332, saved
-    #[arg(long, value_name = "PORT")]
-    rpcport: Option<u16>,
-
-    /// Bitcoin RPC cookie file, default: --bitcoindir/.cookie, saved
-    #[arg(long, value_name = "PATH")]
-    rpccookiefile: Option<String>,
-
-    /// Bitcoin RPC username, saved
-    #[arg(long, value_name = "USERNAME")]
-    rpcuser: Option<String>,
-
-    /// Bitcoin RPC password, saved
-    #[arg(long, value_name = "PASSWORD")]
-    rpcpassword: Option<String>,
-
-    /// Delay between runs, default: 0, saved
-    #[arg(long, value_name = "SECONDS")]
-    delay: Option<u64>,
-
-    /// DEV: Activate checking address hashes for collisions when indexing, default: false, saved
-    #[arg(long, value_name = "BOOL")]
-    check_collisions: Option<bool>,
-}
-
-impl RunConfig {
-    pub fn import(config_args: Option<RunConfig>) -> color_eyre::Result<Self> {
-        let path = dot_brk_path();
-
-        let _ = fs::create_dir_all(&path);
-
-        let path = path.join("config.toml");
-
-        let mut config_saved = Self::read(&path);
-
-        if let Some(mut config_args) = config_args {
-            if let Some(bitcoindir) = config_args.bitcoindir.take() {
-                config_saved.bitcoindir = Some(bitcoindir);
-            }
-
-            if let Some(blocksdir) = config_args.blocksdir.take() {
-                config_saved.blocksdir = Some(blocksdir);
-            }
-
-            if let Some(brkdir) = config_args.brkdir.take() {
-                config_saved.brkdir = Some(brkdir);
-            }
-
-            if let Some(mode) = config_args.mode.take() {
-                config_saved.mode = Some(mode);
-            }
-
-            if let Some(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(website) = config_args.website.take() {
-                config_saved.website = Some(website);
-            }
-
-            if let Some(rpcconnect) = config_args.rpcconnect.take() {
-                config_saved.rpcconnect = Some(rpcconnect);
-            }
-
-            if let Some(rpcport) = config_args.rpcport.take() {
-                config_saved.rpcport = Some(rpcport);
-            }
-
-            if let Some(rpccookiefile) = config_args.rpccookiefile.take() {
-                config_saved.rpccookiefile = Some(rpccookiefile);
-            }
-
-            if let Some(rpcuser) = config_args.rpcuser.take() {
-                config_saved.rpcuser = Some(rpcuser);
-            }
-
-            if let Some(rpcpassword) = config_args.rpcpassword.take() {
-                config_saved.rpcpassword = Some(rpcpassword);
-            }
-
-            if let Some(delay) = config_args.delay.take() {
-                config_saved.delay = Some(delay);
-            }
-
-            if let Some(check_collisions) = config_args.check_collisions.take() {
-                config_saved.check_collisions = Some(check_collisions);
-            }
-
-            if config_args != RunConfig::default() {
-                dbg!(config_args);
-                panic!("Didn't consume the full config")
-            }
-        }
-
-        let config = config_saved;
-
-        config.check();
-
-        config.write(&path)?;
-
-        // info!("Configuration {{");
-        // info!("  bitcoindir: {:?}", config.bitcoindir);
-        // info!("  brkdir: {:?}", config.brkdir);
-        // info!("  mode: {:?}", config.mode);
-        // info!("  website: {:?}", config.website);
-        // info!("  rpcconnect: {:?}", config.rpcconnect);
-        // info!("  rpcport: {:?}", config.rpcport);
-        // info!("  rpccookiefile: {:?}", config.rpccookiefile);
-        // info!("  rpcuser: {:?}", config.rpcuser);
-        // info!("  rpcpassword: {:?}", config.rpcpassword);
-        // info!("  delay: {:?}", config.delay);
-        // info!("}}");
-
-        Ok(config)
-    }
-
-    fn check(&self) {
-        if !self.bitcoindir().is_dir() {
-            println!("{:?} isn't a valid directory", self.bitcoindir());
-            println!("Please use the --bitcoindir parameter to set a valid path.");
-            println!("Run the program with '-h' for help.");
-            std::process::exit(1);
-        }
-
-        if !self.blocksdir().is_dir() {
-            println!("{:?} isn't a valid directory", self.blocksdir());
-            println!("Please use the --blocksdir parameter to set a valid path.");
-            println!("Run the program with '-h' for help.");
-            std::process::exit(1);
-        }
-
-        if !self.brkdir().is_dir() {
-            println!("{:?} isn't a valid directory", self.brkdir());
-            println!("Please use the --brkdir parameter to set a valid path.");
-            println!("Run the program with '-h' for help.");
-            std::process::exit(1);
-        }
-
-        if self.rpc_auth().is_err() {
-            println!(
-                "No way found to authenticate the RPC client, please either set --rpccookiefile or --rpcuser and --rpcpassword.\nRun the program with '-h' for help."
-            );
-            std::process::exit(1);
-        }
-    }
-
-    fn read(path: &Path) -> Self {
-        fs::read_to_string(path).map_or_else(
-            |_| RunConfig::default(),
-            |contents| toml::from_str(&contents).unwrap_or_default(),
-        )
-    }
-
-    fn write(&self, path: &Path) -> std::io::Result<()> {
-        fs::write(path, toml::to_string(self).unwrap())
-    }
-
-    pub fn rpc(&self) -> color_eyre::Result<&'static Client> {
-        Ok(Box::leak(Box::new(rpc::Client::new(
-            &format!(
-                "http://{}:{}",
-                self.rpcconnect().unwrap_or(&"localhost".to_string()),
-                self.rpcport().unwrap_or(8332)
-            ),
-            self.rpc_auth().unwrap(),
-        )?)))
-    }
-
-    fn rpc_auth(&self) -> color_eyre::Result<Auth> {
-        let cookie = self.path_cookiefile();
-
-        if cookie.is_file() {
-            Ok(Auth::CookieFile(cookie))
-        } else if self.rpcuser.is_some() && self.rpcpassword.is_some() {
-            Ok(Auth::UserPass(
-                self.rpcuser.clone().unwrap(),
-                self.rpcpassword.clone().unwrap(),
-            ))
-        } else {
-            Err(eyre!("Failed to find correct auth"))
-        }
-    }
-
-    fn rpcconnect(&self) -> Option<&String> {
-        self.rpcconnect.as_ref()
-    }
-
-    fn rpcport(&self) -> Option<u16> {
-        self.rpcport
-    }
-
-    pub fn delay(&self) -> Option<u64> {
-        self.delay
-    }
-
-    pub fn bitcoindir(&self) -> PathBuf {
-        self.bitcoindir
-            .as_ref()
-            .map_or_else(default_bitcoin_path, |s| Self::fix_user_path(s.as_ref()))
-    }
-
-    pub fn blocksdir(&self) -> PathBuf {
-        self.blocksdir.as_ref().map_or_else(
-            || self.bitcoindir().join("blocks"),
-            |blocksdir| Self::fix_user_path(blocksdir.as_str()),
-        )
-    }
-
-    pub fn brkdir(&self) -> PathBuf {
-        self.brkdir
-            .as_ref()
-            .map_or_else(default_brk_path, |s| Self::fix_user_path(s.as_ref()))
-    }
-
-    pub fn outputsdir(&self) -> PathBuf {
-        self.brkdir().join("outputs")
-    }
-
-    pub fn harsdir(&self) -> PathBuf {
-        self.outputsdir().join("hars")
-    }
-
-    pub fn process(&self) -> bool {
-        self.mode
-            .is_none_or(|m| m == Mode::All || m == Mode::Processor)
-    }
-
-    pub fn serve(&self) -> bool {
-        self.mode
-            .is_none_or(|m| m == Mode::All || m == Mode::Server)
-    }
-
-    fn path_cookiefile(&self) -> PathBuf {
-        self.rpccookiefile.as_ref().map_or_else(
-            || self.bitcoindir().join(".cookie"),
-            |p| Self::fix_user_path(p.as_str()),
-        )
-    }
-
-    fn fix_user_path(path: &str) -> PathBuf {
-        let fix = move |pattern: &str| {
-            if path.starts_with(pattern) {
-                let path = &path
-                    .replace(&format!("{pattern}/"), "")
-                    .replace(pattern, "");
-
-                let home = std::env::var("HOME").unwrap();
-
-                Some(Path::new(&home).join(path))
-            } else {
-                None
-            }
-        };
-
-        fix("~").unwrap_or_else(|| fix("$HOME").unwrap_or_else(|| PathBuf::from(&path)))
-    }
-
-    pub fn website(&self) -> Website {
-        self.website.unwrap_or(Website::KiboMoney)
-    }
-
-    pub fn fetch(&self) -> bool {
-        self.fetch.is_none_or(|b| b)
-    }
-
-    pub fn fetcher(&self) -> Option<Fetcher> {
-        self.fetch()
-            .then(|| Fetcher::import(Some(self.harsdir().as_path())).unwrap())
-    }
-
-    pub fn compressed(&self) -> bool {
-        self.compressed.is_none_or(|b| b)
-    }
-
-    pub fn check_collisions(&self) -> bool {
-        self.check_collisions.is_some_and(|b| b)
-    }
-}
-
-#[derive(
-    Default,
-    Debug,
-    Clone,
-    Copy,
-    Parser,
-    ValueEnum,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-)]
-pub enum Mode {
-    #[default]
-    All,
-    Processor,
-    Server,
-}
@@ -0,0 +1,23 @@
+use clap_derive::{Parser, ValueEnum};
+use serde::{Deserialize, Serialize};
+
+#[derive(
+    Default,
+    Debug,
+    Clone,
+    Copy,
+    Parser,
+    ValueEnum,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+)]
+pub enum Services {
+    #[default]
+    All,
+    Processor,
+    Server,
+}
@@ -4,16 +4,22 @@ 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

 [dependencies]
+bitcoin = { workspace = true }
+bitcoincore-rpc = { workspace = true }
 brk_core = { workspace = true }
 brk_exit = { workspace = true }
 brk_fetcher = { workspace = true }
 brk_indexer = { workspace = true }
 brk_logger = { workspace = true }
 brk_parser = { workspace = true }
+brk_state = { workspace = true }
 brk_vec = { workspace = true }
 color-eyre = { workspace = true }
 fjall = { workspace = true }
+jiff = { workspace = true }
 log = { workspace = true }
+rayon = { workspace = true }
@@ -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>
@@ -1,64 +0,0 @@
-use std::path::Path;
-
-use brk_core::dot_brk_path;
-use brk_indexer::Indexer;
-
-pub fn main() -> color_eyre::Result<()> {
-    color_eyre::install()?;
-
-    brk_logger::init(Some(Path::new(".log")));
-
-    let outputs_dir = dot_brk_path().join("outputs");
-    // let outputs_dir = Path::new("../../_outputs");
-
-    let compressed = false;
-
-    let mut indexer = Indexer::new(outputs_dir.as_path(), compressed, true)?;
-    indexer.import_stores()?;
-    indexer.import_vecs()?;
-
-    let height_to_timestamp = &indexer.vecs().height_to_timestamp;
-
-    dbg!(height_to_timestamp.len());
-
-    // height_to_timestamp.iter().for_each(|t| {
-    //     dbg!(t);
-    // });
-
-    // let index = max_from.min(A::from(self.len()));
-    let mut height_to_timestamp_iter = height_to_timestamp.iter();
-    // height_to_timestamp.iter().for_each(|t| {
-    //     dbg!(t);
-    // });
-    (0..2).for_each(|i| {
-        dbg!(height_to_timestamp_iter.get_(i));
-    });
-    //     for_each(|t| {
-    //     dbg!(t);
-    // });
-    // .try_for_each(|(height, timestamp)| -> Result<()> {
-    //     let interval = height.decremented().map_or(Timestamp::ZERO, |prev_h| {
-    //         dbg!((height, prev_h));
-    //         let prev_timestamp = height_to_timestamp_iter
-    //             .nth(prev_h.unwrap_to_usize())
-    //             .context("To work")
-    //             .inspect_err(|_| {
-    //                 dbg!(prev_h);
-    //             })
-    //             .unwrap()
-    //             .1
-    //             .into_inner();
-    //         timestamp
-    //             .into_inner()
-    //             .checked_sub(prev_timestamp)
-    //             .unwrap_or(Timestamp::ZERO)
-    //         // Ok(())
-    //     });
-
-    //     Ok(())
-    //     // let (i, v) = t((a, b.into_inner(), self, &mut other_iter));
-    //     // self.forced_push_at(i, v, exit)
-    // })?;
-
-    Ok(())
-}
@@ -1,11 +1,12 @@
-use std::path::Path;
+use std::{path::Path, thread};

 use brk_computer::Computer;
-use brk_core::default_bitcoin_path;
+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_parser::Parser;
+use brk_vec::{Computation, Format};

 pub fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;
@@ -14,31 +15,42 @@ pub fn main() -> color_eyre::Result<()> {

    let bitcoin_dir = default_bitcoin_path();

-    let rpc = Box::leak(Box::new(rpc::Client::new(
+    let rpc = Box::leak(Box::new(bitcoincore_rpc::Client::new(
        "http://localhost:8332",
-        rpc::Auth::CookieFile(bitcoin_dir.join(".cookie")),
+        bitcoincore_rpc::Auth::CookieFile(bitcoin_dir.join(".cookie")),
    )?));
    let exit = Exit::new();

-    let parser = Parser::new(bitcoin_dir.join("blocks"), rpc);
+    // 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 = Path::new("../../_outputs");
+            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 format = Format::Raw;

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

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

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

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

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

-    Ok(())
+            Ok(())
+        })?
+        .join()
+        .unwrap()
 }
@@ -3,56 +3,58 @@
 #![doc = include_str!("../examples/main.rs")]
 #![doc = "```"]

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

+use brk_core::Version;
 use brk_exit::Exit;
 use brk_fetcher::Fetcher;
-use brk_indexer::{Indexer, Indexes};
-pub use brk_parser::rpc;
+use brk_indexer::Indexer;
+use brk_vec::{Computation, Format};

-mod storage;
+mod stores;
+mod utils;
+mod vecs;

-use brk_vec::Compressed;
 use log::info;
-use storage::{Stores, Vecs};
+use stores::Stores;
+use vecs::Vecs;

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

+const VERSION: Version = Version::ONE;
+
 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) -> color_eyre::Result<()> {
-        self.vecs = Some(Vecs::import(
-            &self.path.join("vecs/computed"),
-            self.fetcher.is_some(),
-            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_dir: &Path,
+        indexer: &Indexer,
+        computation: Computation,
+        fetcher: Option<Fetcher>,
+        format: Format,
+    ) -> color_eyre::Result<Self> {
+        Ok(Self {
+            vecs: Vecs::import(
+                // TODO: Give self.path, join inside import
+                &outputs_dir.join("vecs/computed"),
+                VERSION + Version::ZERO,
+                indexer,
+                fetcher.is_some(),
+                computation,
+                format,
+            )?,
+            stores: Stores::import(
+                // TODO: Give self.path, join inside import
+                &outputs_dir.join("stores"),
+                VERSION + Version::ZERO,
+                &indexer.stores.keyspace,
+            )?,
+            fetcher,
+        })
    }
 }

@@ -60,34 +62,11 @@ impl Computer {
    pub fn compute(
        &mut self,
        indexer: &mut Indexer,
-        starting_indexes: Indexes,
+        starting_indexes: brk_indexer::Indexes,
        exit: &Exit,
    ) -> color_eyre::Result<()> {
        info!("Computing...");
-
-        self.vecs.as_mut().unwrap().compute(
-            indexer,
-            starting_indexes,
-            self.fetcher.as_mut(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn vecs(&self) -> &Vecs {
-        self.vecs.as_ref().unwrap()
-    }
-
-    pub fn mut_vecs(&mut self) -> &mut Vecs {
-        self.vecs.as_mut().unwrap()
-    }
-
-    pub fn stores(&self) -> &Stores {
-        self.stores.as_ref().unwrap()
-    }
-
-    pub fn mut_stores(&mut self) -> &mut Stores {
-        self.stores.as_mut().unwrap()
+        self.vecs
+            .compute(indexer, starting_indexes, self.fetcher.as_mut(), exit)
    }
 }
@@ -1,5 +0,0 @@
-mod stores;
-mod vecs;
-
-pub use stores::*;
-pub use vecs::*;
@@ -1,155 +0,0 @@
-use std::path::Path;
-
-use brk_core::{DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex};
-use brk_exit::Exit;
-use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, Version};
-
-use crate::storage::{ComputedType, EagerVec, Indexes, indexes};
-
-use super::{ComputedVecBuilder, StorableVecGeneatorOptions};
-
-#[derive(Clone)]
-pub struct ComputedVecsFromDateindex<T>
-where
-    T: ComputedType + PartialOrd,
-{
-    pub dateindex: EagerVec<DateIndex, T>,
-    pub dateindex_extra: ComputedVecBuilder<DateIndex, T>,
-    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
-    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
-    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
-    pub yearindex: ComputedVecBuilder<YearIndex, T>,
-    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
-}
-
-const VERSION: Version = Version::ZERO;
-
-impl<T> ComputedVecsFromDateindex<T>
-where
-    T: ComputedType,
-{
-    pub fn forced_import(
-        path: &Path,
-        name: &str,
-        version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let version = VERSION + version;
-
-        let dateindex_extra = ComputedVecBuilder::forced_import(
-            path,
-            name,
-            version,
-            compressed,
-            options.copy_self_extra(),
-        )?;
-
-        let options = options.remove_percentiles();
-
-        Ok(Self {
-            dateindex: EagerVec::forced_import(
-                &path.join(format!("dateindex_to_{name}")),
-                version,
-                compressed,
-            )?,
-            dateindex_extra,
-            weekindex: 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)?,
-            decadeindex: ComputedVecBuilder::forced_import(
-                path, name, version, compressed, options,
-            )?,
-        })
-    }
-
-    pub fn compute<F>(
-        &mut self,
-        indexer: &Indexer,
-        indexes: &indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-        mut compute: F,
-    ) -> color_eyre::Result<()>
-    where
-        F: FnMut(
-            &mut EagerVec<DateIndex, T>,
-            &Indexer,
-            &indexes::Vecs,
-            &Indexes,
-            &Exit,
-        ) -> Result<()>,
-    {
-        compute(
-            &mut self.dateindex,
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-        )?;
-
-        self.dateindex_extra
-            .extend(starting_indexes.dateindex, self.dateindex.vec(), exit)?;
-
-        self.weekindex.compute(
-            starting_indexes.weekindex,
-            self.dateindex.vec(),
-            indexes.weekindex_to_first_dateindex.vec(),
-            indexes.weekindex_to_dateindex_count.vec(),
-            exit,
-        )?;
-
-        self.monthindex.compute(
-            starting_indexes.monthindex,
-            self.dateindex.vec(),
-            indexes.monthindex_to_first_dateindex.vec(),
-            indexes.monthindex_to_dateindex_count.vec(),
-            exit,
-        )?;
-
-        self.quarterindex.from_aligned(
-            starting_indexes.quarterindex,
-            &self.monthindex,
-            indexes.quarterindex_to_first_monthindex.vec(),
-            indexes.quarterindex_to_monthindex_count.vec(),
-            exit,
-        )?;
-
-        self.yearindex.from_aligned(
-            starting_indexes.yearindex,
-            &self.monthindex,
-            indexes.yearindex_to_first_monthindex.vec(),
-            indexes.yearindex_to_monthindex_count.vec(),
-            exit,
-        )?;
-
-        self.decadeindex.from_aligned(
-            starting_indexes.decadeindex,
-            &self.yearindex,
-            indexes.decadeindex_to_first_yearindex.vec(),
-            indexes.decadeindex_to_yearindex_count.vec(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
-        [
-            vec![self.dateindex.any_vec()],
-            self.dateindex_extra.any_vecs(),
-            self.weekindex.any_vecs(),
-            self.monthindex.any_vecs(),
-            self.quarterindex.any_vecs(),
-            self.yearindex.any_vecs(),
-            self.decadeindex.any_vecs(),
-        ]
-        .concat()
-    }
-}
@@ -1,198 +0,0 @@
-use std::path::Path;
-
-use brk_core::{
-    DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, WeekIndex, YearIndex,
-};
-use brk_exit::Exit;
-use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, StoredVec, Version};
-
-use crate::storage::{ComputedType, EagerVec, Indexes, indexes};
-
-use super::{ComputedVecBuilder, StorableVecGeneatorOptions};
-
-#[derive(Clone)]
-pub struct ComputedVecsFromHeight<T>
-where
-    T: ComputedType + PartialOrd,
-{
-    pub height: Option<EagerVec<Height, T>>,
-    pub height_extra: 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>,
-    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
-    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
-}
-
-const VERSION: Version = Version::ZERO;
-
-impl<T> ComputedVecsFromHeight<T>
-where
-    T: ComputedType + Ord + From<f64>,
-    f64: From<T>,
-{
-    pub fn forced_import(
-        path: &Path,
-        name: &str,
-        compute_source: bool,
-        version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let version = VERSION + version;
-
-        let height = compute_source.then(|| {
-            EagerVec::forced_import(&path.join(format!("height_to_{name}")), version, compressed)
-                .unwrap()
-        });
-
-        let height_extra = ComputedVecBuilder::forced_import(
-            path,
-            name,
-            version,
-            compressed,
-            options.copy_self_extra(),
-        )?;
-
-        let dateindex =
-            ComputedVecBuilder::forced_import(path, name, version, compressed, options)?;
-
-        let options = options.remove_percentiles();
-
-        Ok(Self {
-            height,
-            height_extra,
-            dateindex,
-            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,
-            )?,
-        })
-    }
-
-    pub fn compute_all<F>(
-        &mut self,
-        indexer: &Indexer,
-        indexes: &indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-        mut compute: F,
-    ) -> color_eyre::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,
-        )?;
-
-        self.compute_rest(indexes, starting_indexes, exit, None)?;
-
-        Ok(())
-    }
-
-    pub fn compute_rest(
-        &mut self,
-        indexes: &indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-        height: Option<&StoredVec<Height, T>>,
-    ) -> color_eyre::Result<()> {
-        let height = height.unwrap_or_else(|| self.height.as_ref().unwrap().vec());
-
-        self.height_extra
-            .extend(starting_indexes.height, height, exit)?;
-
-        self.dateindex.compute(
-            starting_indexes.dateindex,
-            height,
-            indexes.dateindex_to_first_height.vec(),
-            indexes.dateindex_to_height_count.vec(),
-            exit,
-        )?;
-
-        self.weekindex.from_aligned(
-            starting_indexes.weekindex,
-            &self.dateindex,
-            indexes.weekindex_to_first_dateindex.vec(),
-            indexes.weekindex_to_dateindex_count.vec(),
-            exit,
-        )?;
-
-        self.monthindex.from_aligned(
-            starting_indexes.monthindex,
-            &self.dateindex,
-            indexes.monthindex_to_first_dateindex.vec(),
-            indexes.monthindex_to_dateindex_count.vec(),
-            exit,
-        )?;
-
-        self.quarterindex.from_aligned(
-            starting_indexes.quarterindex,
-            &self.monthindex,
-            indexes.quarterindex_to_first_monthindex.vec(),
-            indexes.quarterindex_to_monthindex_count.vec(),
-            exit,
-        )?;
-
-        self.yearindex.from_aligned(
-            starting_indexes.yearindex,
-            &self.monthindex,
-            indexes.yearindex_to_first_monthindex.vec(),
-            indexes.yearindex_to_monthindex_count.vec(),
-            exit,
-        )?;
-
-        self.decadeindex.from_aligned(
-            starting_indexes.decadeindex,
-            &self.yearindex,
-            indexes.decadeindex_to_first_yearindex.vec(),
-            indexes.decadeindex_to_yearindex_count.vec(),
-            exit,
-        )?;
-
-        self.difficultyepoch.compute(
-            starting_indexes.difficultyepoch,
-            height,
-            indexes.difficultyepoch_to_first_height.vec(),
-            indexes.difficultyepoch_to_height_count.vec(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
-        [
-            self.height.as_ref().map_or(vec![], |v| vec![v.any_vec()]),
-            self.height_extra.any_vecs(),
-            self.dateindex.any_vecs(),
-            self.weekindex.any_vecs(),
-            self.difficultyepoch.any_vecs(),
-            self.monthindex.any_vecs(),
-            self.quarterindex.any_vecs(),
-            self.yearindex.any_vecs(),
-            // self.halvingepoch.as_any_vecs(),
-            self.decadeindex.any_vecs(),
-        ]
-        .concat()
-    }
-}
@@ -1,206 +0,0 @@
-use std::path::Path;
-
-use brk_core::{
-    DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, TxIndex, WeekIndex,
-    YearIndex,
-};
-use brk_exit::Exit;
-use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, StoredVec, Version};
-
-use crate::storage::{ComputedType, EagerVec, Indexes, indexes};
-
-use super::{ComputedVecBuilder, StorableVecGeneatorOptions};
-
-#[derive(Clone)]
-pub struct ComputedVecsFromTxindex<T>
-where
-    T: ComputedType + PartialOrd,
-{
-    pub txindex: Option<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>,
-    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
-    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
-}
-
-const VERSION: Version = Version::ZERO;
-
-impl<T> ComputedVecsFromTxindex<T>
-where
-    T: ComputedType + Ord + From<f64>,
-    f64: From<T>,
-{
-    pub fn forced_import(
-        path: &Path,
-        name: &str,
-        compute_source: bool,
-        version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let version = VERSION + version;
-
-        let txindex = compute_source.then(|| {
-            EagerVec::forced_import(
-                &path.join(format!("txindex_to_{name}")),
-                version,
-                compressed,
-            )
-            .unwrap()
-        });
-
-        let height = ComputedVecBuilder::forced_import(path, name, version, compressed, options)?;
-
-        let options = options.remove_percentiles();
-
-        Ok(Self {
-            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,
-            )?,
-        })
-    }
-
-    pub fn compute_all<F>(
-        &mut self,
-        indexer: &Indexer,
-        indexes: &indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-        mut compute: F,
-    ) -> color_eyre::Result<()>
-    where
-        F: FnMut(
-            &mut EagerVec<TxIndex, T>,
-            &Indexer,
-            &indexes::Vecs,
-            &Indexes,
-            &Exit,
-        ) -> Result<()>,
-    {
-        compute(
-            self.txindex.as_mut().unwrap(),
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-        )?;
-
-        self.compute_rest(indexer, indexes, starting_indexes, exit, None)?;
-
-        Ok(())
-    }
-
-    pub fn compute_rest(
-        &mut self,
-        indexer: &Indexer,
-        indexes: &indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-        txindex: Option<&StoredVec<TxIndex, T>>,
-    ) -> color_eyre::Result<()> {
-        let txindex = txindex.unwrap_or_else(|| self.txindex.as_ref().unwrap().vec());
-
-        self.height.compute(
-            starting_indexes.height,
-            txindex,
-            indexer.vecs().height_to_first_txindex.vec(),
-            indexes.height_to_txindex_count.vec(),
-            exit,
-        )?;
-
-        self.dateindex.from_aligned(
-            starting_indexes.dateindex,
-            &self.height,
-            indexes.dateindex_to_first_height.vec(),
-            indexes.dateindex_to_height_count.vec(),
-            exit,
-        )?;
-
-        self.weekindex.from_aligned(
-            starting_indexes.weekindex,
-            &self.dateindex,
-            indexes.weekindex_to_first_dateindex.vec(),
-            indexes.weekindex_to_dateindex_count.vec(),
-            exit,
-        )?;
-
-        self.monthindex.from_aligned(
-            starting_indexes.monthindex,
-            &self.dateindex,
-            indexes.monthindex_to_first_dateindex.vec(),
-            indexes.monthindex_to_dateindex_count.vec(),
-            exit,
-        )?;
-
-        self.quarterindex.from_aligned(
-            starting_indexes.quarterindex,
-            &self.monthindex,
-            indexes.quarterindex_to_first_monthindex.vec(),
-            indexes.quarterindex_to_monthindex_count.vec(),
-            exit,
-        )?;
-
-        self.yearindex.from_aligned(
-            starting_indexes.yearindex,
-            &self.monthindex,
-            indexes.yearindex_to_first_monthindex.vec(),
-            indexes.yearindex_to_monthindex_count.vec(),
-            exit,
-        )?;
-
-        self.decadeindex.from_aligned(
-            starting_indexes.decadeindex,
-            &self.yearindex,
-            indexes.decadeindex_to_first_yearindex.vec(),
-            indexes.decadeindex_to_yearindex_count.vec(),
-            exit,
-        )?;
-
-        self.difficultyepoch.from_aligned(
-            starting_indexes.difficultyepoch,
-            &self.height,
-            indexes.difficultyepoch_to_first_height.vec(),
-            indexes.difficultyepoch_to_height_count.vec(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
-        [
-            self.txindex.as_ref().map_or(vec![], |v| vec![v.any_vec()]),
-            self.height.any_vecs(),
-            self.dateindex.any_vecs(),
-            self.weekindex.any_vecs(),
-            self.difficultyepoch.any_vecs(),
-            self.monthindex.any_vecs(),
-            self.quarterindex.any_vecs(),
-            self.yearindex.any_vecs(),
-            // self.halvingepoch.as_any_vecs(),
-            self.decadeindex.any_vecs(),
-        ]
-        .concat()
-    }
-}
@@ -1,158 +0,0 @@
-use std::path::Path;
-
-use brk_core::{Bitcoin, Dollars, Sats, TxIndex};
-use brk_exit::Exit;
-use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, StoredVec, Version};
-
-use crate::storage::{
-    EagerVec, marketprice,
-    vecs::{Indexes, indexes},
-};
-
-use super::{ComputedVecsFromTxindex, StorableVecGeneatorOptions};
-
-#[derive(Clone)]
-pub struct ComputedValueVecsFromTxindex {
-    pub sats: ComputedVecsFromTxindex<Sats>,
-    pub bitcoin: ComputedVecsFromTxindex<Bitcoin>,
-    pub dollars: Option<ComputedVecsFromTxindex<Dollars>>,
-}
-
-const VERSION: Version = Version::ONE;
-
-impl ComputedValueVecsFromTxindex {
-    pub fn forced_import(
-        path: &Path,
-        name: &str,
-        compute_source: bool,
-        version: Version,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-        compute_dollars: bool,
-    ) -> color_eyre::Result<Self> {
-        Ok(Self {
-            sats: ComputedVecsFromTxindex::forced_import(
-                path,
-                name,
-                compute_source,
-                VERSION + version,
-                compressed,
-                options,
-            )?,
-            bitcoin: ComputedVecsFromTxindex::forced_import(
-                path,
-                &format!("{name}_in_btc"),
-                true,
-                VERSION + version,
-                compressed,
-                options,
-            )?,
-            dollars: compute_dollars.then(|| {
-                ComputedVecsFromTxindex::forced_import(
-                    path,
-                    &format!("{name}_in_usd"),
-                    true,
-                    VERSION + version,
-                    compressed,
-                    options,
-                )
-                .unwrap()
-            }),
-        })
-    }
-
-    pub fn compute_all<F>(
-        &mut self,
-        indexer: &Indexer,
-        indexes: &indexes::Vecs,
-        marketprices: Option<&marketprice::Vecs>,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-        mut compute: F,
-    ) -> color_eyre::Result<()>
-    where
-        F: FnMut(
-            &mut EagerVec<TxIndex, Sats>,
-            &Indexer,
-            &indexes::Vecs,
-            &Indexes,
-            &Exit,
-        ) -> Result<()>,
-    {
-        compute(
-            self.sats.txindex.as_mut().unwrap(),
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-        )?;
-
-        self.compute_rest(indexer, indexes, marketprices, starting_indexes, exit, None)?;
-
-        Ok(())
-    }
-
-    pub fn compute_rest(
-        &mut self,
-        indexer: &Indexer,
-        indexes: &indexes::Vecs,
-        marketprices: Option<&marketprice::Vecs>,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-        txindex: Option<&StoredVec<TxIndex, Sats>>,
-    ) -> color_eyre::Result<()> {
-        if let Some(txindex) = txindex.as_ref() {
-            self.sats
-                .compute_rest(indexer, indexes, starting_indexes, exit, Some(txindex))?;
-        } else {
-            self.sats
-                .compute_rest(indexer, indexes, starting_indexes, exit, None)?;
-        }
-
-        let txindex = txindex.unwrap_or_else(|| self.sats.txindex.as_ref().unwrap().vec());
-
-        self.bitcoin.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_from_sats(starting_indexes.txindex, txindex, exit)
-            },
-        )?;
-
-        let txindex = self.bitcoin.txindex.as_mut().unwrap().mut_vec();
-
-        if let Some(dollars) = self.dollars.as_mut() {
-            let price = marketprices.unwrap().chainindexes_to_close.height.vec();
-
-            dollars.compute_all(
-                indexer,
-                indexes,
-                starting_indexes,
-                exit,
-                |v, _, indexes, starting_indexes, exit| {
-                    v.compute_from_bitcoin(
-                        starting_indexes.txindex,
-                        txindex,
-                        indexes.txindex_to_height.vec(),
-                        price,
-                        exit,
-                    )
-                },
-            )?;
-        }
-
-        Ok(())
-    }
-
-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
-        [
-            self.sats.any_vecs(),
-            self.bitcoin.any_vecs(),
-            self.dollars.as_ref().map_or(vec![], |v| v.any_vecs()),
-        ]
-        .concat()
-    }
-}
@@ -1,944 +0,0 @@
-use std::{fs, ops::Deref, path::Path};
-
-use brk_core::{
-    Date, DateIndex, DecadeIndex, DifficultyEpoch, EmptyOutputIndex, HalvingEpoch, Height,
-    InputIndex, MonthIndex, OpReturnIndex, OutputIndex, P2AIndex, P2MSIndex, P2PK33Index,
-    P2PK65Index, P2PKHIndex, P2SHIndex, P2TRIndex, P2WPKHIndex, P2WSHIndex, QuarterIndex,
-    StoredUsize, Timestamp, TxIndex, UnknownOutputIndex, WeekIndex, YearIndex,
-};
-use brk_exit::Exit;
-use brk_indexer::Indexer;
-use brk_vec::{Compressed, Version};
-
-use super::EagerVec;
-
-#[derive(Clone)]
-pub struct Vecs {
-    pub dateindex_to_date: EagerVec<DateIndex, Date>,
-    pub dateindex_to_dateindex: EagerVec<DateIndex, DateIndex>,
-    pub dateindex_to_first_height: EagerVec<DateIndex, Height>,
-    pub dateindex_to_height_count: EagerVec<DateIndex, StoredUsize>,
-    pub dateindex_to_monthindex: EagerVec<DateIndex, MonthIndex>,
-    pub dateindex_to_weekindex: EagerVec<DateIndex, WeekIndex>,
-    pub decadeindex_to_decadeindex: EagerVec<DecadeIndex, DecadeIndex>,
-    pub decadeindex_to_first_yearindex: EagerVec<DecadeIndex, YearIndex>,
-    pub decadeindex_to_yearindex_count: EagerVec<DecadeIndex, StoredUsize>,
-    pub difficultyepoch_to_difficultyepoch: EagerVec<DifficultyEpoch, DifficultyEpoch>,
-    pub difficultyepoch_to_first_height: EagerVec<DifficultyEpoch, Height>,
-    pub difficultyepoch_to_height_count: EagerVec<DifficultyEpoch, StoredUsize>,
-    pub emptyoutputindex_to_emptyoutputindex: EagerVec<EmptyOutputIndex, EmptyOutputIndex>,
-    pub halvingepoch_to_first_height: EagerVec<HalvingEpoch, Height>,
-    pub halvingepoch_to_halvingepoch: EagerVec<HalvingEpoch, HalvingEpoch>,
-    pub height_to_date: EagerVec<Height, Date>,
-    pub height_to_date_fixed: EagerVec<Height, Date>,
-    pub height_to_dateindex: EagerVec<Height, DateIndex>,
-    pub height_to_difficultyepoch: EagerVec<Height, DifficultyEpoch>,
-    pub height_to_halvingepoch: EagerVec<Height, HalvingEpoch>,
-    pub height_to_height: EagerVec<Height, Height>,
-    pub height_to_timestamp_fixed: EagerVec<Height, Timestamp>,
-    pub height_to_txindex_count: EagerVec<Height, StoredUsize>,
-    pub inputindex_to_inputindex: EagerVec<InputIndex, InputIndex>,
-    pub monthindex_to_dateindex_count: EagerVec<MonthIndex, StoredUsize>,
-    pub monthindex_to_first_dateindex: EagerVec<MonthIndex, DateIndex>,
-    pub monthindex_to_monthindex: EagerVec<MonthIndex, MonthIndex>,
-    pub monthindex_to_quarterindex: EagerVec<MonthIndex, QuarterIndex>,
-    pub monthindex_to_yearindex: EagerVec<MonthIndex, YearIndex>,
-    pub opreturnindex_to_opreturnindex: EagerVec<OpReturnIndex, OpReturnIndex>,
-    pub outputindex_to_outputindex: EagerVec<OutputIndex, OutputIndex>,
-    pub p2aindex_to_p2aindex: EagerVec<P2AIndex, P2AIndex>,
-    pub p2msindex_to_p2msindex: EagerVec<P2MSIndex, P2MSIndex>,
-    pub p2pk33index_to_p2pk33index: EagerVec<P2PK33Index, P2PK33Index>,
-    pub p2pk65index_to_p2pk65index: EagerVec<P2PK65Index, P2PK65Index>,
-    pub p2pkhindex_to_p2pkhindex: EagerVec<P2PKHIndex, P2PKHIndex>,
-    pub p2shindex_to_p2shindex: EagerVec<P2SHIndex, P2SHIndex>,
-    pub p2trindex_to_p2trindex: EagerVec<P2TRIndex, P2TRIndex>,
-    pub p2wpkhindex_to_p2wpkhindex: EagerVec<P2WPKHIndex, P2WPKHIndex>,
-    pub p2wshindex_to_p2wshindex: EagerVec<P2WSHIndex, P2WSHIndex>,
-    pub quarterindex_to_first_monthindex: EagerVec<QuarterIndex, MonthIndex>,
-    pub quarterindex_to_monthindex_count: EagerVec<QuarterIndex, StoredUsize>,
-    pub quarterindex_to_quarterindex: EagerVec<QuarterIndex, QuarterIndex>,
-    pub txindex_to_height: EagerVec<TxIndex, Height>,
-    pub txindex_to_txindex: EagerVec<TxIndex, TxIndex>,
-    pub unknownoutputindex_to_unknownoutputindex: EagerVec<UnknownOutputIndex, UnknownOutputIndex>,
-    pub weekindex_to_dateindex_count: EagerVec<WeekIndex, StoredUsize>,
-    pub weekindex_to_first_dateindex: EagerVec<WeekIndex, DateIndex>,
-    pub weekindex_to_weekindex: EagerVec<WeekIndex, WeekIndex>,
-    pub yearindex_to_decadeindex: EagerVec<YearIndex, DecadeIndex>,
-    pub yearindex_to_first_monthindex: EagerVec<YearIndex, MonthIndex>,
-    pub yearindex_to_monthindex_count: EagerVec<YearIndex, StoredUsize>,
-    pub yearindex_to_yearindex: EagerVec<YearIndex, YearIndex>,
-}
-
-impl Vecs {
-    pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
-        Ok(Self {
-            dateindex_to_date: EagerVec::forced_import(
-                &path.join("dateindex_to_date"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_dateindex: EagerVec::forced_import(
-                &path.join("dateindex_to_dateindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_first_height: EagerVec::forced_import(
-                &path.join("dateindex_to_first_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_date: EagerVec::forced_import(
-                &path.join("height_to_date"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_date_fixed: EagerVec::forced_import(
-                &path.join("height_to_date_fixed"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_dateindex: EagerVec::forced_import(
-                &path.join("height_to_dateindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_height: EagerVec::forced_import(
-                &path.join("height_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            txindex_to_height: EagerVec::forced_import(
-                &path.join("txindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            difficultyepoch_to_first_height: EagerVec::forced_import(
-                &path.join("difficultyepoch_to_first_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            halvingepoch_to_first_height: EagerVec::forced_import(
-                &path.join("halvingepoch_to_first_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            weekindex_to_first_dateindex: EagerVec::forced_import(
-                &path.join("weekindex_to_first_dateindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            monthindex_to_first_dateindex: EagerVec::forced_import(
-                &path.join("monthindex_to_first_dateindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            yearindex_to_first_monthindex: EagerVec::forced_import(
-                &path.join("yearindex_to_first_monthindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            decadeindex_to_first_yearindex: EagerVec::forced_import(
-                &path.join("decadeindex_to_first_yearindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_weekindex: EagerVec::forced_import(
-                &path.join("dateindex_to_weekindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_monthindex: EagerVec::forced_import(
-                &path.join("dateindex_to_monthindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            monthindex_to_yearindex: EagerVec::forced_import(
-                &path.join("monthindex_to_yearindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            yearindex_to_decadeindex: EagerVec::forced_import(
-                &path.join("yearindex_to_decadeindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_difficultyepoch: EagerVec::forced_import(
-                &path.join("height_to_difficultyepoch"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_halvingepoch: EagerVec::forced_import(
-                &path.join("height_to_halvingepoch"),
-                Version::ZERO,
-                compressed,
-            )?,
-            weekindex_to_weekindex: EagerVec::forced_import(
-                &path.join("weekindex_to_weekindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            monthindex_to_monthindex: EagerVec::forced_import(
-                &path.join("monthindex_to_monthindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            yearindex_to_yearindex: EagerVec::forced_import(
-                &path.join("yearindex_to_yearindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            decadeindex_to_decadeindex: EagerVec::forced_import(
-                &path.join("decadeindex_to_decadeindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            difficultyepoch_to_difficultyepoch: EagerVec::forced_import(
-                &path.join("difficultyepoch_to_difficultyepoch"),
-                Version::ZERO,
-                compressed,
-            )?,
-            halvingepoch_to_halvingepoch: EagerVec::forced_import(
-                &path.join("halvingepoch_to_halvingepoch"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_timestamp_fixed: EagerVec::forced_import(
-                &path.join("height_to_timestamp_fixed"),
-                Version::ZERO,
-                compressed,
-            )?,
-            monthindex_to_quarterindex: EagerVec::forced_import(
-                &path.join("monthindex_to_quarterindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            quarterindex_to_first_monthindex: EagerVec::forced_import(
-                &path.join("quarterindex_to_first_monthindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            quarterindex_to_quarterindex: EagerVec::forced_import(
-                &path.join("quarterindex_to_quarterindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2pk33index_to_p2pk33index: EagerVec::forced_import(
-                &path.join("p2pk33index_to_p2pk33index"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2pk65index_to_p2pk65index: EagerVec::forced_import(
-                &path.join("p2pk65index_to_p2pk65index"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2pkhindex_to_p2pkhindex: EagerVec::forced_import(
-                &path.join("p2pkhindex_to_p2pkhindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2shindex_to_p2shindex: EagerVec::forced_import(
-                &path.join("p2shindex_to_p2shindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2trindex_to_p2trindex: EagerVec::forced_import(
-                &path.join("p2trindex_to_p2trindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2wpkhindex_to_p2wpkhindex: EagerVec::forced_import(
-                &path.join("p2wpkhindex_to_p2wpkhindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2wshindex_to_p2wshindex: EagerVec::forced_import(
-                &path.join("p2wshindex_to_p2wshindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            txindex_to_txindex: EagerVec::forced_import(
-                &path.join("txindex_to_txindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            inputindex_to_inputindex: EagerVec::forced_import(
-                &path.join("inputindex_to_inputindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            emptyoutputindex_to_emptyoutputindex: EagerVec::forced_import(
-                &path.join("emptyoutputindex_to_emptyoutputindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2msindex_to_p2msindex: EagerVec::forced_import(
-                &path.join("p2msindex_to_p2msindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            opreturnindex_to_opreturnindex: EagerVec::forced_import(
-                &path.join("opreturnindex_to_opreturnindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2aindex_to_p2aindex: EagerVec::forced_import(
-                &path.join("p2aindex_to_p2aindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            unknownoutputindex_to_unknownoutputindex: EagerVec::forced_import(
-                &path.join("unknownoutputindex_to_unknownoutputindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            outputindex_to_outputindex: EagerVec::forced_import(
-                &path.join("outputindex_to_outputindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_txindex_count: EagerVec::forced_import(
-                &path.join("height_to_txindex_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_height_count: EagerVec::forced_import(
-                &path.join("dateindex_to_height_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-            weekindex_to_dateindex_count: EagerVec::forced_import(
-                &path.join("weekindex_to_dateindex_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-            difficultyepoch_to_height_count: EagerVec::forced_import(
-                &path.join("difficultyepoch_to_height_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-            monthindex_to_dateindex_count: EagerVec::forced_import(
-                &path.join("monthindex_to_dateindex_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-            quarterindex_to_monthindex_count: EagerVec::forced_import(
-                &path.join("quarterindex_to_monthindex_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-            yearindex_to_monthindex_count: EagerVec::forced_import(
-                &path.join("yearindex_to_monthindex_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-            decadeindex_to_yearindex_count: EagerVec::forced_import(
-                &path.join("decadeindex_to_yearindex_count"),
-                Version::ZERO,
-                compressed,
-            )?,
-        })
-    }
-
-    pub fn compute(
-        &mut self,
-        indexer: &Indexer,
-        starting_indexes: brk_indexer::Indexes,
-        exit: &Exit,
-    ) -> color_eyre::Result<Indexes> {
-        let indexer_vecs = indexer.vecs();
-
-        // ---
-        // OutputIndex
-        // ---
-
-        self.outputindex_to_outputindex.compute_range(
-            starting_indexes.outputindex,
-            indexer_vecs.outputindex_to_value.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2pk33index_to_p2pk33index.compute_range(
-            starting_indexes.p2pk33index,
-            indexer_vecs.p2pk33index_to_p2pk33bytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2pk65index_to_p2pk65index.compute_range(
-            starting_indexes.p2pk65index,
-            indexer_vecs.p2pk65index_to_p2pk65bytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2pkhindex_to_p2pkhindex.compute_range(
-            starting_indexes.p2pkhindex,
-            indexer_vecs.p2pkhindex_to_p2pkhbytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2shindex_to_p2shindex.compute_range(
-            starting_indexes.p2shindex,
-            indexer_vecs.p2shindex_to_p2shbytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2trindex_to_p2trindex.compute_range(
-            starting_indexes.p2trindex,
-            indexer_vecs.p2trindex_to_p2trbytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2wpkhindex_to_p2wpkhindex.compute_range(
-            starting_indexes.p2wpkhindex,
-            indexer_vecs.p2wpkhindex_to_p2wpkhbytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2wshindex_to_p2wshindex.compute_range(
-            starting_indexes.p2wshindex,
-            indexer_vecs.p2wshindex_to_p2wshbytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.emptyoutputindex_to_emptyoutputindex.compute_range(
-            starting_indexes.emptyoutputindex,
-            indexer_vecs.emptyoutputindex_to_txindex.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2msindex_to_p2msindex.compute_range(
-            starting_indexes.p2msindex,
-            indexer_vecs.p2msindex_to_txindex.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.opreturnindex_to_opreturnindex.compute_range(
-            starting_indexes.opreturnindex,
-            indexer_vecs.opreturnindex_to_txindex.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.p2aindex_to_p2aindex.compute_range(
-            starting_indexes.p2aindex,
-            indexer_vecs.p2aindex_to_p2abytes.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.unknownoutputindex_to_unknownoutputindex
-            .compute_range(
-                starting_indexes.unknownoutputindex,
-                indexer_vecs.unknownoutputindex_to_txindex.vec(),
-                |i| (i, i),
-                exit,
-            )?;
-
-        // ---
-        // InputIndex
-        // ---
-
-        self.inputindex_to_inputindex.compute_range(
-            starting_indexes.inputindex,
-            indexer_vecs.inputindex_to_outputindex.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        // ---
-        // TxIndex
-        // ---
-
-        self.txindex_to_txindex.compute_range(
-            starting_indexes.txindex,
-            indexer_vecs.txindex_to_txid.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.height_to_txindex_count.compute_count_from_indexes(
-            starting_indexes.height,
-            indexer_vecs.height_to_first_txindex.vec(),
-            indexer_vecs.txindex_to_txid.vec(),
-            exit,
-        )?;
-
-        self.txindex_to_height.compute_inverse_less_to_more(
-            starting_indexes.height,
-            indexer_vecs.height_to_first_txindex.vec(),
-            self.height_to_txindex_count.vec(),
-            exit,
-        )?;
-
-        // ---
-        // Height
-        // ---
-
-        self.height_to_height.compute_range(
-            starting_indexes.height,
-            indexer_vecs.height_to_timestamp.vec(),
-            |h| (h, h),
-            exit,
-        )?;
-
-        self.height_to_date.compute_transform(
-            starting_indexes.height,
-            indexer_vecs.height_to_timestamp.vec(),
-            |(h, t, ..)| (h, Date::from(t)),
-            exit,
-        )?;
-
-        let mut prev_timestamp_fixed = None;
-        self.height_to_timestamp_fixed.compute_transform(
-            starting_indexes.height,
-            indexer_vecs.height_to_timestamp.vec(),
-            |(h, timestamp, height_to_timestamp_fixed_iter)| {
-                if prev_timestamp_fixed.is_none() {
-                    if let Some(prev_h) = h.decremented() {
-                        prev_timestamp_fixed.replace(
-                            height_to_timestamp_fixed_iter
-                                .iter()
-                                .unwrap_get_inner(prev_h),
-                        );
-                    }
-                }
-                let timestamp_fixed =
-                    prev_timestamp_fixed.map_or(timestamp, |prev_d| prev_d.max(timestamp));
-                prev_timestamp_fixed.replace(timestamp_fixed);
-                (h, timestamp_fixed)
-            },
-            exit,
-        )?;
-
-        self.height_to_date_fixed.compute_transform(
-            starting_indexes.height,
-            self.height_to_timestamp_fixed.vec(),
-            |(h, t, ..)| (h, Date::from(t)),
-            exit,
-        )?;
-
-        let decremented_starting_height = starting_indexes.height.decremented().unwrap_or_default();
-
-        // ---
-        // DateIndex
-        // ---
-
-        let starting_dateindex = self
-            .height_to_dateindex
-            .iter()
-            .get_inner(decremented_starting_height)
-            .unwrap_or_default();
-
-        self.height_to_dateindex.compute_transform(
-            starting_indexes.height,
-            self.height_to_date_fixed.vec(),
-            |(h, d, ..)| (h, DateIndex::try_from(d).unwrap()),
-            exit,
-        )?;
-
-        let starting_dateindex = if let Some(dateindex) = self
-            .height_to_dateindex
-            .iter()
-            .get_inner(decremented_starting_height)
-        {
-            starting_dateindex.min(dateindex)
-        } else {
-            starting_dateindex
-        };
-
-        self.dateindex_to_first_height
-            .compute_inverse_more_to_less(
-                starting_indexes.height,
-                self.height_to_dateindex.vec(),
-                exit,
-            )?;
-
-        self.dateindex_to_dateindex.compute_range(
-            starting_dateindex,
-            self.dateindex_to_first_height.vec(),
-            |di| (di, di),
-            exit,
-        )?;
-
-        self.dateindex_to_date.compute_range(
-            starting_dateindex,
-            self.dateindex_to_dateindex.vec(),
-            |di| (di, Date::from(di)),
-            exit,
-        )?;
-
-        self.dateindex_to_height_count.compute_count_from_indexes(
-            starting_dateindex,
-            self.dateindex_to_first_height.vec(),
-            indexer_vecs.height_to_weight.vec(),
-            exit,
-        )?;
-
-        // ---
-        // WeekIndex
-        // ---
-
-        let starting_weekindex = self
-            .dateindex_to_weekindex
-            .iter()
-            .get_inner(starting_dateindex)
-            .unwrap_or_default();
-
-        self.dateindex_to_weekindex.compute_range(
-            starting_dateindex,
-            self.dateindex_to_dateindex.vec(),
-            |di| (di, WeekIndex::from(di)),
-            exit,
-        )?;
-
-        self.weekindex_to_first_dateindex
-            .compute_inverse_more_to_less(
-                starting_dateindex,
-                self.dateindex_to_weekindex.vec(),
-                exit,
-            )?;
-
-        self.weekindex_to_weekindex.compute_range(
-            starting_weekindex,
-            self.weekindex_to_first_dateindex.vec(),
-            |wi| (wi, wi),
-            exit,
-        )?;
-
-        self.weekindex_to_dateindex_count
-            .compute_count_from_indexes(
-                starting_weekindex,
-                self.weekindex_to_first_dateindex.vec(),
-                self.dateindex_to_date.vec(),
-                exit,
-            )?;
-
-        // ---
-        // DifficultyEpoch
-        // ---
-
-        let starting_difficultyepoch = self
-            .height_to_difficultyepoch
-            .iter()
-            .get_inner(decremented_starting_height)
-            .unwrap_or_default();
-
-        self.height_to_difficultyepoch.compute_range(
-            starting_indexes.height,
-            self.height_to_height.vec(),
-            |h| (h, DifficultyEpoch::from(h)),
-            exit,
-        )?;
-
-        self.difficultyepoch_to_first_height
-            .compute_inverse_more_to_less(
-                starting_indexes.height,
-                self.height_to_difficultyepoch.vec(),
-                exit,
-            )?;
-
-        self.difficultyepoch_to_difficultyepoch.compute_range(
-            starting_difficultyepoch,
-            self.difficultyepoch_to_first_height.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.difficultyepoch_to_height_count
-            .compute_count_from_indexes(
-                starting_difficultyepoch,
-                self.difficultyepoch_to_first_height.vec(),
-                self.height_to_date.vec(),
-                exit,
-            )?;
-
-        // ---
-        // MonthIndex
-        // ---
-
-        let starting_monthindex = self
-            .dateindex_to_monthindex
-            .iter()
-            .get_inner(starting_dateindex)
-            .unwrap_or_default();
-
-        self.dateindex_to_monthindex.compute_range(
-            starting_dateindex,
-            self.dateindex_to_dateindex.vec(),
-            |di| (di, MonthIndex::from(di)),
-            exit,
-        )?;
-
-        self.monthindex_to_first_dateindex
-            .compute_inverse_more_to_less(
-                starting_dateindex,
-                self.dateindex_to_monthindex.vec(),
-                exit,
-            )?;
-
-        self.monthindex_to_monthindex.compute_range(
-            starting_monthindex,
-            self.monthindex_to_first_dateindex.vec(),
-            |mi| (mi, mi),
-            exit,
-        )?;
-
-        self.monthindex_to_dateindex_count
-            .compute_count_from_indexes(
-                starting_monthindex,
-                self.monthindex_to_first_dateindex.vec(),
-                self.dateindex_to_date.vec(),
-                exit,
-            )?;
-
-        // ---
-        // QuarterIndex
-        // ---
-
-        let starting_quarterindex = self
-            .monthindex_to_quarterindex
-            .iter()
-            .get_inner(starting_monthindex)
-            .unwrap_or_default();
-
-        self.monthindex_to_quarterindex.compute_range(
-            starting_monthindex,
-            self.monthindex_to_monthindex.vec(),
-            |mi| (mi, QuarterIndex::from(mi)),
-            exit,
-        )?;
-
-        self.quarterindex_to_first_monthindex
-            .compute_inverse_more_to_less(
-                starting_monthindex,
-                self.monthindex_to_quarterindex.vec(),
-                exit,
-            )?;
-
-        // let quarter_count = self.quarterindex_to_first_monthindex.len();
-
-        self.quarterindex_to_quarterindex.compute_range(
-            starting_quarterindex,
-            self.quarterindex_to_first_monthindex.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.quarterindex_to_monthindex_count
-            .compute_count_from_indexes(
-                starting_quarterindex,
-                self.quarterindex_to_first_monthindex.vec(),
-                self.monthindex_to_monthindex.vec(),
-                exit,
-            )?;
-
-        // ---
-        // YearIndex
-        // ---
-
-        let starting_yearindex = self
-            .monthindex_to_yearindex
-            .iter()
-            .get_inner(starting_monthindex)
-            .unwrap_or_default();
-
-        self.monthindex_to_yearindex.compute_range(
-            starting_monthindex,
-            self.monthindex_to_monthindex.vec(),
-            |i| (i, YearIndex::from(i)),
-            exit,
-        )?;
-
-        self.yearindex_to_first_monthindex
-            .compute_inverse_more_to_less(
-                starting_monthindex,
-                self.monthindex_to_yearindex.vec(),
-                exit,
-            )?;
-
-        self.yearindex_to_yearindex.compute_range(
-            starting_yearindex,
-            self.yearindex_to_first_monthindex.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.yearindex_to_monthindex_count
-            .compute_count_from_indexes(
-                starting_yearindex,
-                self.yearindex_to_first_monthindex.vec(),
-                self.monthindex_to_monthindex.vec(),
-                exit,
-            )?;
-        // ---
-        // HalvingEpoch
-        // ---
-
-        let starting_halvingepoch = self
-            .height_to_halvingepoch
-            .iter()
-            .get_inner(decremented_starting_height)
-            .unwrap_or_default();
-
-        self.height_to_halvingepoch.compute_range(
-            starting_indexes.height,
-            self.height_to_height.vec(),
-            |h| (h, HalvingEpoch::from(h)),
-            exit,
-        )?;
-
-        self.halvingepoch_to_first_height
-            .compute_inverse_more_to_less(
-                starting_indexes.height,
-                self.height_to_halvingepoch.vec(),
-                exit,
-            )?;
-
-        self.halvingepoch_to_halvingepoch.compute_range(
-            starting_halvingepoch,
-            self.halvingepoch_to_first_height.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        // ---
-        // DecadeIndex
-        // ---
-
-        let starting_decadeindex = self
-            .yearindex_to_decadeindex
-            .iter()
-            .get_inner(starting_yearindex)
-            .unwrap_or_default();
-
-        self.yearindex_to_decadeindex.compute_range(
-            starting_yearindex,
-            self.yearindex_to_yearindex.vec(),
-            |i| (i, DecadeIndex::from(i)),
-            exit,
-        )?;
-
-        self.decadeindex_to_first_yearindex
-            .compute_inverse_more_to_less(
-                starting_yearindex,
-                self.yearindex_to_decadeindex.vec(),
-                exit,
-            )?;
-
-        self.decadeindex_to_decadeindex.compute_range(
-            starting_decadeindex,
-            self.decadeindex_to_first_yearindex.vec(),
-            |i| (i, i),
-            exit,
-        )?;
-
-        self.decadeindex_to_yearindex_count
-            .compute_count_from_indexes(
-                starting_decadeindex,
-                self.decadeindex_to_first_yearindex.vec(),
-                self.yearindex_to_yearindex.vec(),
-                exit,
-            )?;
-
-        Ok(Indexes {
-            indexes: starting_indexes,
-            dateindex: starting_dateindex,
-            weekindex: starting_weekindex,
-            monthindex: starting_monthindex,
-            quarterindex: starting_quarterindex,
-            yearindex: starting_yearindex,
-            decadeindex: starting_decadeindex,
-            difficultyepoch: starting_difficultyepoch,
-            halvingepoch: starting_halvingepoch,
-        })
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn brk_vec::AnyStoredVec> {
-        vec![
-            self.dateindex_to_date.any_vec(),
-            self.dateindex_to_dateindex.any_vec(),
-            self.dateindex_to_first_height.any_vec(),
-            self.dateindex_to_height_count.any_vec(),
-            self.dateindex_to_monthindex.any_vec(),
-            self.dateindex_to_weekindex.any_vec(),
-            self.decadeindex_to_decadeindex.any_vec(),
-            self.decadeindex_to_first_yearindex.any_vec(),
-            self.decadeindex_to_yearindex_count.any_vec(),
-            self.difficultyepoch_to_difficultyepoch.any_vec(),
-            self.difficultyepoch_to_first_height.any_vec(),
-            self.difficultyepoch_to_height_count.any_vec(),
-            self.emptyoutputindex_to_emptyoutputindex.any_vec(),
-            self.halvingepoch_to_first_height.any_vec(),
-            self.halvingepoch_to_halvingepoch.any_vec(),
-            self.height_to_date.any_vec(),
-            self.height_to_date_fixed.any_vec(),
-            self.height_to_dateindex.any_vec(),
-            self.height_to_difficultyepoch.any_vec(),
-            self.height_to_halvingepoch.any_vec(),
-            self.height_to_height.any_vec(),
-            self.height_to_timestamp_fixed.any_vec(),
-            self.height_to_txindex_count.any_vec(),
-            self.inputindex_to_inputindex.any_vec(),
-            self.monthindex_to_dateindex_count.any_vec(),
-            self.monthindex_to_first_dateindex.any_vec(),
-            self.monthindex_to_monthindex.any_vec(),
-            self.monthindex_to_quarterindex.any_vec(),
-            self.monthindex_to_yearindex.any_vec(),
-            self.opreturnindex_to_opreturnindex.any_vec(),
-            self.outputindex_to_outputindex.any_vec(),
-            self.p2aindex_to_p2aindex.any_vec(),
-            self.p2msindex_to_p2msindex.any_vec(),
-            self.p2pk33index_to_p2pk33index.any_vec(),
-            self.p2pk65index_to_p2pk65index.any_vec(),
-            self.p2pkhindex_to_p2pkhindex.any_vec(),
-            self.p2shindex_to_p2shindex.any_vec(),
-            self.p2trindex_to_p2trindex.any_vec(),
-            self.p2wpkhindex_to_p2wpkhindex.any_vec(),
-            self.p2wshindex_to_p2wshindex.any_vec(),
-            self.quarterindex_to_first_monthindex.any_vec(),
-            self.quarterindex_to_monthindex_count.any_vec(),
-            self.quarterindex_to_quarterindex.any_vec(),
-            self.txindex_to_height.any_vec(),
-            self.txindex_to_txindex.any_vec(),
-            self.unknownoutputindex_to_unknownoutputindex.any_vec(),
-            self.weekindex_to_dateindex_count.any_vec(),
-            self.weekindex_to_first_dateindex.any_vec(),
-            self.weekindex_to_weekindex.any_vec(),
-            self.yearindex_to_decadeindex.any_vec(),
-            self.yearindex_to_first_monthindex.any_vec(),
-            self.yearindex_to_monthindex_count.any_vec(),
-            self.yearindex_to_yearindex.any_vec(),
-        ]
-    }
-}
-
-pub struct Indexes {
-    indexes: brk_indexer::Indexes,
-    pub dateindex: DateIndex,
-    pub weekindex: WeekIndex,
-    pub monthindex: MonthIndex,
-    pub quarterindex: QuarterIndex,
-    pub yearindex: YearIndex,
-    pub decadeindex: DecadeIndex,
-    pub difficultyepoch: DifficultyEpoch,
-    pub halvingepoch: HalvingEpoch,
-}
-
-impl Deref for Indexes {
-    type Target = brk_indexer::Indexes;
-    fn deref(&self) -> &Self::Target {
-        &self.indexes
-    }
-}
@@ -1,89 +0,0 @@
-use std::{fs, path::Path};
-
-use brk_exit::Exit;
-use brk_fetcher::Fetcher;
-use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed};
-
-pub mod blocks;
-pub mod grouped;
-pub mod indexes;
-pub mod marketprice;
-pub mod mining;
-pub mod transactions;
-pub mod vec;
-
-pub use indexes::Indexes;
-pub use vec::*;
-
-#[derive(Clone)]
-pub struct Vecs {
-    pub indexes: indexes::Vecs,
-    pub blocks: blocks::Vecs,
-    pub mining: mining::Vecs,
-    pub transactions: transactions::Vecs,
-    pub marketprice: Option<marketprice::Vecs>,
-}
-
-impl Vecs {
-    pub fn import(path: &Path, fetch: bool, compressed: Compressed) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
-        Ok(Self {
-            blocks: blocks::Vecs::forced_import(path, compressed)?,
-            indexes: indexes::Vecs::forced_import(path, compressed)?,
-            mining: mining::Vecs::forced_import(path, compressed)?,
-            transactions: transactions::Vecs::forced_import(path, compressed, fetch)?,
-            marketprice: fetch.then(|| marketprice::Vecs::forced_import(path, compressed).unwrap()),
-        })
-    }
-
-    pub fn compute(
-        &mut self,
-        indexer: &Indexer,
-        starting_indexes: brk_indexer::Indexes,
-        fetcher: Option<&mut Fetcher>,
-        exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        let starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
-
-        self.blocks
-            .compute(indexer, &self.indexes, &starting_indexes, exit)?;
-
-        self.mining
-            .compute(indexer, &self.indexes, &starting_indexes, exit)?;
-
-        if let Some(marketprice) = self.marketprice.as_mut() {
-            marketprice.compute(
-                indexer,
-                &self.indexes,
-                &starting_indexes,
-                fetcher.unwrap(),
-                exit,
-            )?;
-        }
-
-        self.transactions.compute(
-            indexer,
-            &self.indexes,
-            &starting_indexes,
-            self.marketprice.as_ref(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
-        [
-            self.indexes.as_any_vecs(),
-            self.blocks.as_any_vecs(),
-            self.mining.as_any_vecs(),
-            self.transactions.as_any_vecs(),
-            self.marketprice
-                .as_ref()
-                .map_or(vec![], |v| v.as_any_vecs()),
-        ]
-        .concat()
-    }
-}
@@ -1,912 +0,0 @@
-use std::{fs, path::Path};
-
-use brk_core::{
-    CheckedSub, Feerate, InputIndex, OutputIndex, Sats, StoredUsize, TxIndex, TxVersion, Weight,
-};
-use brk_exit::Exit;
-use brk_indexer::Indexer;
-use brk_parser::bitcoin;
-use brk_vec::{Compressed, DynamicVec, StoredIndex, Version};
-
-use super::{
-    EagerVec, Indexes,
-    grouped::{
-        ComputedValueVecsFromHeight, ComputedValueVecsFromTxindex, ComputedVecsFromHeight,
-        ComputedVecsFromTxindex, StorableVecGeneatorOptions,
-    },
-    indexes, marketprice,
-};
-
-#[derive(Clone)]
-pub struct Vecs {
-    // pub txindex_to_is_v1: LazyVec<Txindex, bool>,
-    // pub txindex_to_is_v2: LazyVec<Txindex, bool>,
-    // pub txindex_to_is_v3: LazyVec<Txindex, bool>,
-    pub indexes_to_coinbase: ComputedValueVecsFromHeight,
-    pub indexes_to_emptyoutput_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_fee: ComputedValueVecsFromTxindex,
-    pub indexes_to_feerate: ComputedVecsFromTxindex<Feerate>,
-    /// Value == 0 when Coinbase
-    pub indexes_to_input_value: ComputedVecsFromTxindex<Sats>,
-    pub indexes_to_opreturn_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_output_value: ComputedVecsFromTxindex<Sats>,
-    pub indexes_to_p2a_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2ms_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2pk33_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2pk65_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2pkh_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2sh_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2tr_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2wpkh_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_p2wsh_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_subsidy: ComputedValueVecsFromHeight,
-    pub indexes_to_tx_count: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_tx_v1: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_tx_v2: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_tx_v3: ComputedVecsFromHeight<StoredUsize>,
-    pub indexes_to_tx_vsize: ComputedVecsFromTxindex<StoredUsize>,
-    pub indexes_to_tx_weight: ComputedVecsFromTxindex<Weight>,
-    pub indexes_to_unknownoutput_count: ComputedVecsFromHeight<StoredUsize>,
-    pub inputindex_to_value: EagerVec<InputIndex, Sats>,
-    pub indexes_to_input_count: ComputedVecsFromTxindex<StoredUsize>,
-    pub txindex_to_is_coinbase: EagerVec<TxIndex, bool>,
-    pub indexes_to_output_count: ComputedVecsFromTxindex<StoredUsize>,
-    pub txindex_to_vsize: EagerVec<TxIndex, StoredUsize>,
-    pub txindex_to_weight: EagerVec<TxIndex, Weight>,
-}
-
-impl Vecs {
-    pub fn forced_import(
-        path: &Path,
-        compressed: Compressed,
-        compute_dollars: bool,
-    ) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
-        Ok(Self {
-            indexes_to_tx_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "tx_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            // height_to_subsidy: StorableVec::forced_import(&path.join("height_to_subsidy"), Version::ZERO)?,
-            txindex_to_is_coinbase: EagerVec::forced_import(
-                &path.join("txindex_to_is_coinbase"),
-                Version::ZERO,
-                compressed,
-            )?,
-            indexes_to_input_count: ComputedVecsFromTxindex::forced_import(
-                path,
-                "input_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_output_count: ComputedVecsFromTxindex::forced_import(
-                path,
-                "output_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            inputindex_to_value: EagerVec::forced_import(
-                &path.join("inputindex_to_value"),
-                Version::ZERO,
-                compressed,
-            )?,
-            indexes_to_tx_v1: ComputedVecsFromHeight::forced_import(
-                path,
-                "tx_v1",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
-            )?,
-            indexes_to_tx_v2: ComputedVecsFromHeight::forced_import(
-                path,
-                "tx_v2",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
-            )?,
-            indexes_to_tx_v3: ComputedVecsFromHeight::forced_import(
-                path,
-                "tx_v3",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
-            )?,
-            indexes_to_input_value: ComputedVecsFromTxindex::forced_import(
-                path,
-                "input_value",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_output_value: ComputedVecsFromTxindex::forced_import(
-                path,
-                "output_value",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_fee: ComputedValueVecsFromTxindex::forced_import(
-                path,
-                "fee",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_sum()
-                    .add_total()
-                    .add_percentiles()
-                    .add_minmax()
-                    .add_average(),
-                compute_dollars,
-            )?,
-            indexes_to_feerate: ComputedVecsFromTxindex::forced_import(
-                path,
-                "feerate",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_percentiles()
-                    .add_minmax()
-                    .add_average(),
-            )?,
-            txindex_to_weight: EagerVec::forced_import(
-                &path.join("txindex_to_weight"),
-                Version::ZERO,
-                compressed,
-            )?,
-            txindex_to_vsize: EagerVec::forced_import(
-                &path.join("txindex_to_vsize"),
-                Version::ZERO,
-                compressed,
-            )?,
-            indexes_to_tx_vsize: ComputedVecsFromTxindex::forced_import(
-                path,
-                "tx_vsize",
-                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_percentiles()
-                    .add_minmax()
-                    .add_average(),
-            )?,
-            indexes_to_tx_weight: ComputedVecsFromTxindex::forced_import(
-                path,
-                "tx_weight",
-                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_percentiles()
-                    .add_minmax()
-                    .add_average(),
-            )?,
-            indexes_to_subsidy: ComputedValueVecsFromHeight::forced_import(
-                path,
-                "subsidy",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total()
-                    .add_minmax()
-                    .add_average(),
-                compute_dollars,
-            )?,
-            indexes_to_coinbase: ComputedValueVecsFromHeight::forced_import(
-                path,
-                "coinbase",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_sum()
-                    .add_total()
-                    .add_percentiles()
-                    .add_minmax()
-                    .add_average(),
-                compute_dollars,
-            )?,
-            indexes_to_p2a_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2a_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2ms_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2ms_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2pk33_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2pk33_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2pk65_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2pk65_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2pkh_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2pkh_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2sh_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2sh_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2tr_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2tr_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2wpkh_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2wpkh_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_p2wsh_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "p2wsh_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_opreturn_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "opreturn_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_unknownoutput_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "unknownoutput_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-            indexes_to_emptyoutput_count: ComputedVecsFromHeight::forced_import(
-                path,
-                "emptyoutput_count",
-                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default()
-                    .add_average()
-                    .add_minmax()
-                    .add_percentiles()
-                    .add_sum()
-                    .add_total(),
-            )?,
-        })
-    }
-
-    pub fn compute(
-        &mut self,
-        indexer: &Indexer,
-        indexes: &indexes::Vecs,
-        starting_indexes: &Indexes,
-        marketprices: Option<&marketprice::Vecs>,
-        exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        self.indexes_to_tx_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_txindex.vec(),
-                    indexer.vecs().txindex_to_txid.vec(),
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_input_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.txindex,
-                    indexer.vecs().txindex_to_first_inputindex.vec(),
-                    indexer.vecs().inputindex_to_outputindex.vec(),
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_output_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.txindex,
-                    indexer.vecs().txindex_to_first_outputindex.vec(),
-                    indexer.vecs().outputindex_to_value.vec(),
-                    exit,
-                )
-            },
-        )?;
-
-        let compute_indexes_to_tx_vany =
-            |indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredUsize>, txversion| {
-                let mut txindex_to_txversion_iter = indexer.vecs().txindex_to_txversion.iter();
-                indexes_to_tx_vany.compute_all(
-                    indexer,
-                    indexes,
-                    starting_indexes,
-                    exit,
-                    |vec, indexer, _, starting_indexes, exit| {
-                        vec.compute_filtered_count_from_indexes(
-                            starting_indexes.height,
-                            indexer.vecs().height_to_first_txindex.vec(),
-                            indexer.vecs().txindex_to_txid.vec(),
-                            |txindex| {
-                                let v = txindex_to_txversion_iter
-                                    .get(txindex)
-                                    .unwrap()
-                                    .1
-                                    .into_inner();
-                                v == txversion
-                            },
-                            exit,
-                        )
-                    },
-                )
-            };
-        compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v1, TxVersion::ONE)?;
-        compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v2, TxVersion::TWO)?;
-        compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v3, TxVersion::THREE)?;
-
-        self.txindex_to_is_coinbase.compute_is_first_ordered(
-            starting_indexes.txindex,
-            indexes.txindex_to_height.vec(),
-            indexer.vecs().height_to_first_txindex.vec(),
-            exit,
-        )?;
-
-        let mut txindex_to_total_size_iter = indexer.vecs().txindex_to_total_size.iter();
-        self.txindex_to_weight.compute_transform(
-            starting_indexes.txindex,
-            indexer.vecs().txindex_to_base_size.vec(),
-            |(txindex, base_size, ..)| {
-                let total_size = txindex_to_total_size_iter
-                    .get(txindex)
-                    .unwrap()
-                    .1
-                    .into_inner();
-
-                // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
-                let wu = usize::from(base_size) * 3 + usize::from(total_size);
-                let weight = Weight::from(bitcoin::Weight::from_wu_usize(wu));
-
-                (txindex, weight)
-            },
-            exit,
-        )?;
-
-        self.txindex_to_vsize.compute_transform(
-            starting_indexes.txindex,
-            self.txindex_to_weight.vec(),
-            |(txindex, weight, ..)| {
-                let vbytes =
-                    StoredUsize::from(bitcoin::Weight::from(weight).to_vbytes_ceil() as usize);
-                (txindex, vbytes)
-            },
-            exit,
-        )?;
-
-        let mut outputindex_to_value_iter = indexer.vecs().outputindex_to_value.iter();
-        let inputs_len = indexer.vecs().inputindex_to_outputindex.vec().len();
-        self.inputindex_to_value.compute_transform(
-            starting_indexes.inputindex,
-            indexer.vecs().inputindex_to_outputindex.vec(),
-            |(inputindex, outputindex, ..)| {
-                let value = if outputindex == OutputIndex::COINBASE {
-                    Sats::ZERO
-                } else if let Some((_, value)) = outputindex_to_value_iter.get(outputindex) {
-                    value.into_inner()
-                } else {
-                    dbg!(inputindex, outputindex, inputs_len);
-                    panic!()
-                };
-                (inputindex, value)
-            },
-            exit,
-        )?;
-
-        self.indexes_to_output_value.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |vec, indexer, _, starting_indexes, exit| {
-                vec.compute_sum_from_indexes(
-                    starting_indexes.txindex,
-                    indexer.vecs().txindex_to_first_outputindex.vec(),
-                    self.indexes_to_output_count.txindex.as_ref().unwrap().vec(),
-                    indexer.vecs().outputindex_to_value.vec(),
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_input_value.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |vec, indexer, _, starting_indexes, exit| {
-                vec.compute_sum_from_indexes(
-                    starting_indexes.txindex,
-                    indexer.vecs().txindex_to_first_inputindex.vec(),
-                    self.indexes_to_input_count.txindex.as_ref().unwrap().vec(),
-                    self.inputindex_to_value.vec(),
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_fee.compute_all(
-            indexer,
-            indexes,
-            marketprices,
-            starting_indexes,
-            exit,
-            |vec, _, _, starting_indexes, exit| {
-                let mut txindex_to_output_value_iter = self
-                    .indexes_to_output_value
-                    .txindex
-                    .as_ref()
-                    .unwrap()
-                    .iter();
-                vec.compute_transform(
-                    starting_indexes.txindex,
-                    self.indexes_to_input_value.txindex.as_ref().unwrap().vec(),
-                    |(txindex, input_value, ..)| {
-                        if input_value.is_zero() {
-                            (txindex, input_value)
-                        } else {
-                            let output_value =
-                                txindex_to_output_value_iter.unwrap_get_inner(txindex);
-                            (txindex, input_value.checked_sub(output_value).unwrap())
-                        }
-                    },
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_feerate.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |vec, _, _, starting_indexes, exit| {
-                let mut txindex_to_vsize_iter = self.txindex_to_vsize.iter();
-                vec.compute_transform(
-                    starting_indexes.txindex,
-                    self.indexes_to_fee.sats.txindex.as_ref().unwrap().vec(),
-                    |(txindex, fee, ..)| {
-                        let vsize = txindex_to_vsize_iter.unwrap_get_inner(txindex);
-                        (txindex, Feerate::from((fee, vsize)))
-                    },
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_tx_weight.compute_rest(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            Some(self.txindex_to_weight.vec()),
-        )?;
-
-        self.indexes_to_tx_vsize.compute_rest(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            Some(self.txindex_to_vsize.vec()),
-        )?;
-
-        self.indexes_to_subsidy.compute_all(
-            indexer,
-            indexes,
-            marketprices,
-            starting_indexes,
-            exit,
-            |vec, indexer, _, starting_indexes, exit| {
-                let mut txindex_to_first_outputindex_iter =
-                    indexer.vecs().txindex_to_first_outputindex.iter();
-                let mut txindex_to_output_count_iter = self
-                    .indexes_to_output_count
-                    .txindex
-                    .as_ref()
-                    .unwrap()
-                    .iter();
-                let mut outputindex_to_value_iter = indexer.vecs().outputindex_to_value.iter();
-                vec.compute_transform(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_txindex.vec(),
-                    |(height, txindex, ..)| {
-                        let first_outputindex = txindex_to_first_outputindex_iter
-                            .unwrap_get_inner(txindex)
-                            .unwrap_to_usize();
-                        let output_count = txindex_to_output_count_iter.unwrap_get_inner(txindex);
-                        let mut sats = Sats::ZERO;
-                        (first_outputindex..first_outputindex + *output_count).for_each(
-                            |outputindex| {
-                                sats += outputindex_to_value_iter
-                                    .unwrap_get_inner(OutputIndex::from(outputindex));
-                            },
-                        );
-                        (height, sats)
-                    },
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_coinbase.compute_all(
-            indexer,
-            indexes,
-            marketprices,
-            starting_indexes,
-            exit,
-            |vec, _, _, starting_indexes, exit| {
-                let mut indexes_to_fee_sum_iter =
-                    self.indexes_to_fee.sats.height.unwrap_sum().iter();
-                vec.compute_transform(
-                    starting_indexes.height,
-                    self.indexes_to_subsidy.sats.height.as_ref().unwrap().vec(),
-                    |(height, subsidy, ..)| {
-                        let fees = indexes_to_fee_sum_iter.unwrap_get_inner(height);
-                        (height, subsidy.checked_sub(fees).unwrap())
-                    },
-                    exit,
-                )
-            },
-        )?;
-
-        self.indexes_to_p2a_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2aindex.vec(),
-                    indexer.vecs().p2aindex_to_p2abytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2ms_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2msindex.vec(),
-                    indexer.vecs().p2msindex_to_txindex.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2pk33_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2pk33index.vec(),
-                    indexer.vecs().p2pk33index_to_p2pk33bytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2pk65_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2pk65index.vec(),
-                    indexer.vecs().p2pk65index_to_p2pk65bytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2pkh_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2pkhindex.vec(),
-                    indexer.vecs().p2pkhindex_to_p2pkhbytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2sh_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2shindex.vec(),
-                    indexer.vecs().p2shindex_to_p2shbytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2tr_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2trindex.vec(),
-                    indexer.vecs().p2trindex_to_p2trbytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2wpkh_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2wpkhindex.vec(),
-                    indexer.vecs().p2wpkhindex_to_p2wpkhbytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_p2wsh_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_p2wshindex.vec(),
-                    indexer.vecs().p2wshindex_to_p2wshbytes.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_opreturn_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_opreturnindex.vec(),
-                    indexer.vecs().opreturnindex_to_txindex.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_unknownoutput_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_unknownoutputindex.vec(),
-                    indexer.vecs().unknownoutputindex_to_txindex.vec(),
-                    exit,
-                )
-            },
-        )?;
-        self.indexes_to_emptyoutput_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_count_from_indexes(
-                    starting_indexes.height,
-                    indexer.vecs().height_to_first_emptyoutputindex.vec(),
-                    indexer.vecs().emptyoutputindex_to_txindex.vec(),
-                    exit,
-                )
-            },
-        )?;
-
-        Ok(())
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn brk_vec::AnyStoredVec> {
-        [
-            vec![
-                self.txindex_to_is_coinbase.any_vec(),
-                self.inputindex_to_value.any_vec(),
-                self.txindex_to_weight.any_vec(),
-                self.txindex_to_vsize.any_vec(),
-            ],
-            self.indexes_to_tx_count.any_vecs(),
-            self.indexes_to_coinbase.any_vecs(),
-            self.indexes_to_fee.any_vecs(),
-            self.indexes_to_feerate.any_vecs(),
-            self.indexes_to_input_value.any_vecs(),
-            self.indexes_to_output_value.any_vecs(),
-            self.indexes_to_subsidy.any_vecs(),
-            self.indexes_to_tx_v1.any_vecs(),
-            self.indexes_to_tx_v2.any_vecs(),
-            self.indexes_to_tx_v3.any_vecs(),
-            self.indexes_to_tx_vsize.any_vecs(),
-            self.indexes_to_tx_weight.any_vecs(),
-            self.indexes_to_input_count.any_vecs(),
-            self.indexes_to_output_count.any_vecs(),
-            self.indexes_to_p2a_count.any_vecs(),
-            self.indexes_to_p2ms_count.any_vecs(),
-            self.indexes_to_p2pk33_count.any_vecs(),
-            self.indexes_to_p2pk65_count.any_vecs(),
-            self.indexes_to_p2pkh_count.any_vecs(),
-            self.indexes_to_p2sh_count.any_vecs(),
-            self.indexes_to_p2tr_count.any_vecs(),
-            self.indexes_to_p2wpkh_count.any_vecs(),
-            self.indexes_to_p2wsh_count.any_vecs(),
-            self.indexes_to_opreturn_count.any_vecs(),
-            self.indexes_to_unknownoutput_count.any_vecs(),
-            self.indexes_to_emptyoutput_count.any_vecs(),
-        ]
-        .concat()
-    }
-}
@@ -1,540 +0,0 @@
-use core::error;
-use std::{
-    cmp::Ordering,
-    fmt::Debug,
-    ops::Add,
-    path::{Path, PathBuf},
-};
-
-use brk_core::{Bitcoin, CheckedSub, Close, Dollars, Height, Sats, StoredUsize, TxIndex};
-use brk_exit::Exit;
-use brk_vec::{
-    Compressed, DynamicVec, Error, GenericVec, Result, StoredIndex, StoredType, StoredVec,
-    StoredVecIterator, Value, Version,
-};
-use color_eyre::eyre::ContextCompat;
-use log::info;
-
-const ONE_KIB: usize = 1024;
-const ONE_MIB: usize = ONE_KIB * ONE_KIB;
-const MAX_CACHE_SIZE: usize = 210 * ONE_MIB;
-
-#[derive(Debug)]
-pub struct EagerVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    computed_version: Option<Version>,
-    inner: StoredVec<I, T>,
-}
-
-impl<I, T> EagerVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    const SIZE_OF: usize = size_of::<T>();
-
-    pub fn forced_import(
-        path: &Path,
-        version: Version,
-        compressed: Compressed,
-    ) -> brk_vec::Result<Self> {
-        let inner = StoredVec::forced_import(path, version, compressed)?;
-
-        Ok(Self {
-            computed_version: None,
-            inner,
-        })
-    }
-
-    fn safe_truncate_if_needed(&mut self, index: I, exit: &Exit) -> Result<()> {
-        if exit.triggered() {
-            return Ok(());
-        }
-        exit.block();
-        self.inner.truncate_if_needed(index)?;
-        exit.release();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn forced_push_at(&mut self, index: I, value: T, exit: &Exit) -> Result<()> {
-        match self.len().cmp(&index.to_usize()?) {
-            Ordering::Less => {
-                return Err(Error::IndexTooHigh);
-            }
-            ord => {
-                if ord == Ordering::Greater {
-                    self.safe_truncate_if_needed(index, exit)?;
-                }
-                self.inner.push(value);
-            }
-        }
-
-        if self.inner.pushed_len() * Self::SIZE_OF >= MAX_CACHE_SIZE {
-            self.safe_flush(exit)
-        } else {
-            Ok(())
-        }
-    }
-
-    pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {
-        if exit.triggered() {
-            return Ok(());
-        }
-        exit.block();
-        self.inner.flush()?;
-        exit.release();
-        Ok(())
-    }
-
-    fn version(&self) -> Version {
-        self.inner.version()
-    }
-
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-
-    fn file_name(&self) -> String {
-        self.inner.file_name()
-    }
-
-    pub fn vec(&self) -> &StoredVec<I, T> {
-        &self.inner
-    }
-
-    pub fn mut_vec(&mut self) -> &StoredVec<I, T> {
-        &mut self.inner
-    }
-
-    pub fn any_vec(&self) -> &dyn brk_vec::AnyStoredVec {
-        &self.inner
-    }
-
-    pub fn mut_any_vec(&mut self) -> &mut dyn brk_vec::AnyStoredVec {
-        &mut self.inner
-    }
-
-    pub fn path(&self) -> &Path {
-        self.inner.path()
-    }
-
-    #[inline]
-    fn path_computed_version(&self) -> PathBuf {
-        self.inner.path().join("computed_version")
-    }
-
-    fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
-        let path = self.path_computed_version();
-        if version.validate(path.as_ref()).is_err() {
-            self.inner.reset()?;
-        }
-        version.write(path.as_ref())?;
-
-        if self.is_empty() {
-            info!("Computing {}...", self.file_name())
-        }
-
-        Ok(())
-    }
-
-    pub fn iter(&self) -> StoredVecIterator<I, T> {
-        self.into_iter()
-    }
-
-    pub fn compute_range<A, F>(
-        &mut self,
-        max_from: I,
-        other: &StoredVec<I, A>,
-        mut t: F,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        A: StoredType,
-        F: FnMut(I) -> (I, T),
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + other.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        (index.to_usize()?..other.len()).try_for_each(|i| {
-            let (i, v) = t(I::from(i));
-            self.forced_push_at(i, v, exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_transform<A, B, F>(
-        &mut self,
-        max_from: A,
-        other: &StoredVec<A, B>,
-        mut t: F,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        A: StoredIndex,
-        B: StoredType,
-        F: FnMut((A, B, &Self)) -> (I, T),
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + other.version(),
-        )?;
-
-        let index = max_from.min(A::from(self.len()));
-        other.iter_at(index).try_for_each(|(a, b)| {
-            let (i, v) = t((a, b.into_inner(), self));
-            self.forced_push_at(i, v, exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_inverse_more_to_less(
-        &mut self,
-        max_from: T,
-        other: &StoredVec<T, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType + StoredIndex,
-        T: StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + other.version(),
-        )?;
-
-        let index = max_from.min(
-            self.inner
-                .iter()
-                .last()
-                .map_or_else(T::default, |(_, v)| v.into_inner()),
-        );
-        let mut prev_i = None;
-        other.iter_at(index).try_for_each(|(v, i)| -> Result<()> {
-            let i = i.into_inner();
-            if prev_i.is_some_and(|prev_i| prev_i == i) {
-                return Ok(());
-            }
-            if self
-                .inner
-                .get(i)?
-                .is_none_or(|old_v| old_v.into_inner() > v)
-            {
-                self.forced_push_at(i, v, exit)?;
-            }
-            prev_i.replace(i);
-            Ok(())
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_inverse_less_to_more(
-        &mut self,
-        max_from: T,
-        first_indexes: &StoredVec<T, I>,
-        indexes_count: &StoredVec<T, StoredUsize>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType,
-        T: StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + first_indexes.version() + indexes_count.version(),
-        )?;
-
-        let mut indexes_count_iter = indexes_count.iter();
-
-        let index = max_from.min(T::from(self.len()));
-        first_indexes
-            .iter_at(index)
-            .try_for_each(|(value, first_index)| {
-                let first_index = (first_index).to_usize()?;
-                let count = *indexes_count_iter.unwrap_get_inner(value);
-                (first_index..first_index + count)
-                    .try_for_each(|index| self.forced_push_at(I::from(index), value, exit))
-            })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_count_from_indexes<T2, T3>(
-        &mut self,
-        max_from: I,
-        first_indexes: &StoredVec<I, T2>,
-        other_to_else: &StoredVec<T2, T3>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType
-            + StoredIndex
-            + Copy
-            + Add<usize, Output = T2>
-            + CheckedSub<T2>
-            + TryInto<T>
-            + Default,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-        T3: StoredType,
-    {
-        let opt: Option<Box<dyn FnMut(T2) -> bool>> = None;
-        self.compute_filtered_count_from_indexes_(max_from, first_indexes, other_to_else, opt, exit)
-    }
-
-    pub fn compute_filtered_count_from_indexes<T2, T3, F>(
-        &mut self,
-        max_from: I,
-        first_indexes: &StoredVec<I, T2>,
-        other_to_else: &StoredVec<T2, T3>,
-        filter: F,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType
-            + StoredIndex
-            + Copy
-            + Add<usize, Output = T2>
-            + CheckedSub<T2>
-            + TryInto<T>
-            + Default,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-        T3: StoredType,
-        F: FnMut(T2) -> bool,
-    {
-        self.compute_filtered_count_from_indexes_(
-            max_from,
-            first_indexes,
-            other_to_else,
-            Some(Box::new(filter)),
-            exit,
-        )
-    }
-
-    fn compute_filtered_count_from_indexes_<T2, T3>(
-        &mut self,
-        max_from: I,
-        first_indexes: &StoredVec<I, T2>,
-        other_to_else: &StoredVec<T2, T3>,
-        mut filter: Option<Box<dyn FnMut(T2) -> bool + '_>>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType
-            + StoredIndex
-            + Copy
-            + Add<usize, Output = T2>
-            + CheckedSub<T2>
-            + TryInto<T>
-            + Default,
-        T3: StoredType,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + first_indexes.version(), // + last_indexes.version(),
-        )?;
-
-        let mut other_iter = first_indexes.iter();
-        let index = max_from.min(I::from(self.len()));
-        first_indexes
-            .iter_at(index)
-            .try_for_each(|(i, first_index)| {
-                let end = other_iter
-                    .get(i + 1)
-                    .map(|(_, v)| v.into_inner().unwrap_to_usize())
-                    .unwrap_or_else(|| other_to_else.len());
-
-                let range = first_index.unwrap_to_usize()..end;
-                let count = if let Some(filter) = filter.as_mut() {
-                    range.into_iter().filter(|i| filter(T2::from(*i))).count()
-                } else {
-                    range.count()
-                };
-                self.forced_push_at(i, T::from(T2::from(count)), exit)
-            })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_is_first_ordered<A>(
-        &mut self,
-        max_from: I,
-        self_to_other: &StoredVec<I, A>,
-        other_to_self: &StoredVec<A, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType,
-        T: From<bool>,
-        A: StoredIndex + StoredType,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + self_to_other.version() + other_to_self.version(),
-        )?;
-
-        let mut other_to_self_iter = other_to_self.iter();
-        let index = max_from.min(I::from(self.len()));
-        self_to_other.iter_at(index).try_for_each(|(i, other)| {
-            self.forced_push_at(
-                i,
-                T::from(
-                    other_to_self_iter
-                        .get(other.into_inner())
-                        .unwrap()
-                        .1
-                        .into_inner()
-                        == i,
-                ),
-                exit,
-            )
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_sum_from_indexes<T2>(
-        &mut self,
-        max_from: I,
-        first_indexes: &StoredVec<I, T2>,
-        indexes_count: &StoredVec<I, StoredUsize>,
-        source: &StoredVec<T2, T>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<usize> + Add<T, Output = T>,
-        T2: StoredIndex + StoredType,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + first_indexes.version() + indexes_count.version(),
-        )?;
-
-        let mut indexes_count_iter = indexes_count.iter();
-        let mut source_iter = source.iter();
-        let index = max_from.min(I::from(self.len()));
-        first_indexes
-            .iter_at(index)
-            .try_for_each(|(i, first_index)| {
-                let count = *indexes_count_iter.get(i).unwrap().1.into_inner();
-                let first_index = first_index.unwrap_to_usize();
-                let range = first_index..first_index + count;
-                let mut sum = T::from(0_usize);
-                range.into_iter().for_each(|i| {
-                    sum = sum.clone() + source_iter.get(T2::from(i)).unwrap().1.into_inner();
-                });
-                self.forced_push_at(i, sum, exit)
-            })?;
-
-        self.safe_flush(exit)
-    }
-}
-
-impl<I> EagerVec<I, Bitcoin>
-where
-    I: StoredIndex,
-{
-    pub fn compute_from_sats(
-        &mut self,
-        max_from: I,
-        sats: &StoredVec<I, Sats>,
-        exit: &Exit,
-    ) -> Result<()> {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + sats.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        sats.iter_at(index).try_for_each(|(i, sats)| {
-            let (i, v) = (i, Bitcoin::from(sats.into_inner()));
-            self.forced_push_at(i, v, exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-}
-
-impl EagerVec<Height, Dollars> {
-    pub fn compute_from_bitcoin(
-        &mut self,
-        max_from: Height,
-        bitcoin: &StoredVec<Height, Bitcoin>,
-        price: &StoredVec<Height, Close<Dollars>>,
-        exit: &Exit,
-    ) -> Result<()> {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + bitcoin.version(),
-        )?;
-
-        let mut price_iter = price.iter();
-        let index = max_from.min(Height::from(self.len()));
-        bitcoin.iter_at(index).try_for_each(|(i, bitcoin)| {
-            let dollars = price_iter.get(i).unwrap().1.into_inner();
-            let (i, v) = (i, *dollars * bitcoin.into_inner());
-            self.forced_push_at(i, v, exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-}
-
-impl EagerVec<TxIndex, Dollars> {
-    pub fn compute_from_bitcoin(
-        &mut self,
-        max_from: TxIndex,
-        bitcoin: &StoredVec<TxIndex, Bitcoin>,
-        i_to_height: &StoredVec<TxIndex, Height>,
-        price: &StoredVec<Height, Close<Dollars>>,
-        exit: &Exit,
-    ) -> Result<()> {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + bitcoin.version(),
-        )?;
-
-        let mut i_to_height_iter = i_to_height.iter();
-        let mut price_iter = price.iter();
-        let index = max_from.min(TxIndex::from(self.len()));
-        bitcoin.iter_at(index).try_for_each(|(i, bitcoin, ..)| {
-            let height = i_to_height_iter.get(i).unwrap().1.into_inner();
-            let dollars = price_iter.get(height).unwrap().1.into_inner();
-            let (i, v) = (i, *dollars * bitcoin.into_inner());
-            self.forced_push_at(i, v, exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-}
-
-impl<I, T> Clone for EagerVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    fn clone(&self) -> Self {
-        Self {
-            computed_version: self.computed_version,
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-impl<'a, I, T> IntoIterator for &'a EagerVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    type Item = (I, Value<'a, T>);
-    type IntoIter = StoredVecIterator<'a, I, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.inner.into_iter()
-    }
-}
@@ -1,43 +0,0 @@
-use std::fmt::Debug;
-
-use brk_vec::{DynamicVec, GenericVec, StoredIndex, StoredType, StoredVec, Version};
-
-#[derive(Debug)]
-pub struct LazyVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    inner: StoredVec<I, T>,
-}
-
-impl<I, T> LazyVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    const SIZE_OF: usize = size_of::<T>();
-
-    fn version(&self) -> Version {
-        self.inner.version()
-    }
-
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-}
-
-impl<I, T> Clone for LazyVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-        }
-    }
-}
@@ -1,13 +0,0 @@
-mod _type;
-mod eager;
-mod lazy;
-
-pub use _type::*;
-pub use eager::*;
-pub use lazy::*;
-
-#[derive(Debug, Clone, Copy)]
-enum Mode {
-    Lazy,
-    Eager,
-}
@@ -1,7 +1,10 @@
 use std::path::Path;

+use brk_core::Version;
 use fjall::TransactionalKeyspace;

+const _VERSION: Version = Version::ZERO;
+
 #[derive(Clone)]
 pub struct Stores {
    // pub address_to_utxos_received: Store<AddressIndexOutputIndex, Unit>,
@@ -9,18 +12,18 @@ pub struct Stores {
 }

 impl Stores {
-    pub fn import(_: &Path, _: &TransactionalKeyspace) -> color_eyre::Result<Self> {
+    pub fn import(_: &Path, _: Version, _: &TransactionalKeyspace) -> color_eyre::Result<Self> {
        // let address_to_utxos_received = Store::import(
        //     keyspace.clone(),
        //     path,
        //     "address_to_utxos_received",
-        //     Version::ZERO,
+        //     version + VERSION + Version::ZERO,
        // )?;
        // let address_to_utxos_spent = Store::import(
        //     keyspace.clone(),
        //     path,
        //     "address_to_utxos_spent",
-        //     Version::ZERO,
+        //     version + VERSION + Version::ZERO,
        // )?;

        Ok(Self {
@@ -0,0 +1,27 @@
+use std::ops::{Add, Div};
+
+pub fn get_percentile<T>(sorted: &[T], percentile: f64) -> T
+where
+    T: Clone + Div<usize, Output = T> + Add<T, Output = T>,
+{
+    let len = sorted.len();
+
+    if len == 0 {
+        panic!();
+    } else if len == 1 {
+        sorted[0].clone()
+    } else {
+        let index = (len - 1) as f64 * percentile;
+
+        let fract = index.fract();
+
+        if fract != 0.0 {
+            let left = sorted.get(index as usize).unwrap().clone();
+            let right = sorted.get(index.ceil() as usize).unwrap().clone();
+            left / 2 + right / 2
+        } else {
+            // dbg!(sorted.len(), index);
+            sorted.get(index as usize).unwrap().clone()
+        }
+    }
+}
@@ -1,27 +1,28 @@
-use std::{fs, path::Path};
+use std::path::Path;

 use brk_core::{
    CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, StoredUsize,
-    Timestamp, Weight,
+    Timestamp, Version, Weight,
 };
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_parser::bitcoin;
-use brk_vec::{Compressed, Version};
+use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, EagerVec, Format};

 use super::{
-    EagerVec, Indexes,
-    grouped::{ComputedVecsFromDateindex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    Indexes,
+    grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
    indexes,
 };

+const VERSION: Version = Version::ZERO;
+
 #[derive(Clone)]
 pub struct Vecs {
    pub height_to_interval: EagerVec<Height, Timestamp>,
    pub height_to_vbytes: EagerVec<Height, StoredU64>,
    pub difficultyepoch_to_timestamp: EagerVec<DifficultyEpoch, Timestamp>,
    pub halvingepoch_to_timestamp: EagerVec<HalvingEpoch, Timestamp>,
-    pub timeindexes_to_timestamp: ComputedVecsFromDateindex<Timestamp>,
+    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>,
@@ -30,28 +31,33 @@ pub struct Vecs {
 }

 impl Vecs {
-    pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
+    pub fn forced_import(
+        path: &Path,
+        version: Version,
+        _computation: Computation,
+        format: Format,
+    ) -> color_eyre::Result<Self> {
        Ok(Self {
            height_to_interval: EagerVec::forced_import(
-                &path.join("height_to_interval"),
-                Version::ZERO,
-                compressed,
+                path,
+                "interval",
+                version + VERSION + Version::ZERO,
+                format,
            )?,
-            timeindexes_to_timestamp: ComputedVecsFromDateindex::forced_import(
+            timeindexes_to_timestamp: ComputedVecsFromDateIndex::forced_import(
                path,
                "timestamp",
-                Version::ZERO,
-                compressed,
+                true,
+                version + VERSION + Version::ZERO,
+                format,
                StorableVecGeneatorOptions::default().add_first(),
            )?,
            indexes_to_block_interval: ComputedVecsFromHeight::forced_import(
                path,
                "block_interval",
                false,
-                Version::ZERO,
-                compressed,
+                version + VERSION + Version::ZERO,
+                format,
                StorableVecGeneatorOptions::default()
                    .add_percentiles()
                    .add_minmax()
@@ -61,48 +67,59 @@ impl Vecs {
                path,
                "block_count",
                true,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
            )?,
            indexes_to_block_weight: ComputedVecsFromHeight::forced_import(
                path,
                "block_weight",
                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
            )?,
            indexes_to_block_size: ComputedVecsFromHeight::forced_import(
                path,
                "block_size",
                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
            )?,
            height_to_vbytes: EagerVec::forced_import(
-                &path.join("height_to_vbytes"),
-                Version::ZERO,
-                compressed,
+                path,
+                "vbytes",
+                version + VERSION + Version::ZERO,
+                format,
            )?,
            indexes_to_block_vbytes: ComputedVecsFromHeight::forced_import(
                path,
                "block_vbytes",
                false,
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_sum().add_total(),
+                version + VERSION + Version::ZERO,
+                format,
+                StorableVecGeneatorOptions::default()
+                    .add_sum()
+                    .add_cumulative(),
            )?,
            difficultyepoch_to_timestamp: EagerVec::forced_import(
-                &path.join("difficultyepoch_to_timestamp"),
-                Version::ZERO,
-                compressed,
+                path,
+                "timestamp",
+                version + VERSION + Version::ZERO,
+                format,
            )?,
            halvingepoch_to_timestamp: EagerVec::forced_import(
-                &path.join("halvingepoch_to_timestamp"),
-                Version::ZERO,
-                compressed,
+                path,
+                "timestamp",
+                version + VERSION + Version::ZERO,
+                format,
            )?,
        })
    }
@@ -114,7 +131,7 @@ impl Vecs {
        starting_indexes: &Indexes,
        exit: &Exit,
    ) -> color_eyre::Result<()> {
-        self.timeindexes_to_timestamp.compute(
+        self.timeindexes_to_timestamp.compute_all(
            indexer,
            indexes,
            starting_indexes,
@@ -122,7 +139,7 @@ impl Vecs {
            |vec, _, indexes, starting_indexes, exit| {
                vec.compute_transform(
                    starting_indexes.dateindex,
-                    indexes.dateindex_to_date.vec(),
+                    &indexes.dateindex_to_date,
                    |(di, d, ..)| (di, Timestamp::from(d)),
                    exit,
                )
@@ -135,23 +152,19 @@ impl Vecs {
            starting_indexes,
            exit,
            |v, indexer, _, starting_indexes, exit| {
-                let indexer_vecs = indexer.vecs();
-
                v.compute_range(
                    starting_indexes.height,
-                    indexer_vecs.height_to_weight.vec(),
+                    &indexer.vecs.height_to_weight,
                    |h| (h, StoredU32::from(1_u32)),
                    exit,
                )
            },
        )?;

-        let indexer_vecs = indexer.vecs();
-
-        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
+        let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter();
        self.height_to_interval.compute_transform(
            starting_indexes.height,
-            indexer_vecs.height_to_timestamp.vec(),
+            &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);
@@ -168,26 +181,26 @@ impl Vecs {
            indexes,
            starting_indexes,
            exit,
-            Some(self.height_to_interval.vec()),
+            Some(&self.height_to_interval),
        )?;

        self.indexes_to_block_weight.compute_rest(
            indexes,
            starting_indexes,
            exit,
-            Some(indexer_vecs.height_to_weight.vec()),
+            Some(&indexer.vecs.height_to_weight),
        )?;

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

        self.height_to_vbytes.compute_transform(
            starting_indexes.height,
-            indexer_vecs.height_to_weight.vec(),
+            &indexer.vecs.height_to_weight,
            |(h, w, ..)| {
                (
                    h,
@@ -201,43 +214,45 @@ impl Vecs {
            indexes,
            starting_indexes,
            exit,
-            Some(self.height_to_vbytes.vec()),
+            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,
-            indexes.difficultyepoch_to_first_height.vec(),
-            |(i, h, ..)| (i, height_to_timestamp_iter.get(h).unwrap().1.into_inner()),
+            &indexes.difficultyepoch_to_first_height,
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
            exit,
        )?;

        self.halvingepoch_to_timestamp.compute_transform(
            starting_indexes.halvingepoch,
-            indexes.halvingepoch_to_first_height.vec(),
-            |(i, h, ..)| (i, height_to_timestamp_iter.get(h).unwrap().1.into_inner()),
+            &indexes.halvingepoch_to_first_height,
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
            exit,
        )?;

        Ok(())
    }

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

-use brk_core::{CheckedSub, StoredUsize};
+use brk_core::{CheckedSub, Result, StoredUsize, Version};
 use brk_exit::Exit;
-use brk_vec::{Compressed, DynamicVec, Result, StoredIndex, StoredType, StoredVec, Version};
+use brk_vec::{AnyCollectableVec, AnyIterableVec, EagerVec, Format, StoredIndex, StoredType};
 use color_eyre::eyre::ContextCompat;

-use crate::storage::{ComputedType, EagerVec};
+use crate::utils::get_percentile;
+
+use super::ComputedType;

 #[derive(Clone, Debug)]
 pub struct ComputedVecBuilder<I, T>
@@ -13,18 +15,18 @@ where
    I: StoredIndex,
    T: ComputedType,
 {
-    first: Option<EagerVec<I, T>>,
-    average: Option<EagerVec<I, T>>,
-    sum: Option<EagerVec<I, T>>,
-    max: Option<EagerVec<I, T>>,
-    _90p: Option<EagerVec<I, T>>,
-    _75p: Option<EagerVec<I, T>>,
-    median: Option<EagerVec<I, T>>,
-    _25p: Option<EagerVec<I, T>>,
-    _10p: Option<EagerVec<I, T>>,
-    min: Option<EagerVec<I, T>>,
-    last: Option<EagerVec<I, T>>,
-    total: Option<EagerVec<I, T>>,
+    pub first: Option<Box<EagerVec<I, T>>>,
+    pub average: Option<Box<EagerVec<I, T>>>,
+    pub sum: Option<Box<EagerVec<I, T>>>,
+    pub max: Option<Box<EagerVec<I, T>>>,
+    pub _90p: Option<Box<EagerVec<I, T>>>,
+    pub _75p: Option<Box<EagerVec<I, T>>>,
+    pub median: Option<Box<EagerVec<I, T>>>,
+    pub _25p: Option<Box<EagerVec<I, T>>>,
+    pub _10p: Option<Box<EagerVec<I, T>>>,
+    pub min: Option<Box<EagerVec<I, T>>>,
+    pub last: Option<Box<EagerVec<I, T>>>,
+    pub cumulative: Option<Box<EagerVec<I, T>>>,
 }

 const VERSION: Version = Version::ZERO;
@@ -38,118 +40,189 @@ where
        path: &Path,
        name: &str,
        version: Version,
-        compressed: Compressed,
+        format: Format,
        options: StorableVecGeneatorOptions,
    ) -> color_eyre::Result<Self> {
-        let key = I::to_string().split("::").last().unwrap().to_lowercase();
-
        let only_one_active = options.is_only_one_active();

-        let default = || path.join(format!("{key}_to_{name}"));
-
-        let prefix = |s: &str| path.join(format!("{key}_to_{s}_{name}"));
+        let prefix = |s: &str| format!("{s}_{name}");

        let maybe_prefix = |s: &str| {
            if only_one_active {
-                default()
+                name.to_string()
            } else {
                prefix(s)
            }
        };

-        let suffix = |s: &str| path.join(format!("{key}_to_{name}_{s}"));
+        let suffix = |s: &str| format!("{name}_{s}");

        let maybe_suffix = |s: &str| {
            if only_one_active {
-                default()
+                name.to_string()
            } else {
                suffix(s)
            }
        };

-        let version = VERSION + version;
-
        let s = Self {
            first: options.first.then(|| {
-                EagerVec::forced_import(&maybe_prefix("first"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_prefix("first"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
            last: options.last.then(|| {
-                EagerVec::forced_import(
-                    &path.join(format!("{key}_to_{name}")),
-                    version + Version::ZERO,
-                    compressed,
+                Box::new(
+                    EagerVec::forced_import(path, name, version + Version::ZERO, format).unwrap(),
                )
-                .unwrap()
            }),
            min: options.min.then(|| {
-                EagerVec::forced_import(&maybe_suffix("min"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("min"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
            max: options.max.then(|| {
-                EagerVec::forced_import(&maybe_suffix("max"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("max"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
            median: options.median.then(|| {
-                EagerVec::forced_import(
-                    &maybe_suffix("median"),
-                    version + Version::ZERO,
-                    compressed,
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("median"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
                )
-                .unwrap()
            }),
            average: options.average.then(|| {
-                EagerVec::forced_import(
-                    &maybe_suffix("average"),
-                    version + Version::ZERO,
-                    compressed,
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("average"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
                )
-                .unwrap()
            }),
            sum: options.sum.then(|| {
-                EagerVec::forced_import(&maybe_suffix("sum"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &(if !options.last {
+                            name.to_string()
+                        } else {
+                            maybe_suffix("sum")
+                        }),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
-            total: options.total.then(|| {
-                EagerVec::forced_import(&prefix("total"), version + Version::ZERO, compressed)
-                    .unwrap()
+            cumulative: options.cumulative.then(|| {
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &prefix("cumulative"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
            _90p: options._90p.then(|| {
-                EagerVec::forced_import(&maybe_suffix("90p"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("90p"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
            _75p: options._75p.then(|| {
-                EagerVec::forced_import(&maybe_suffix("75p"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("75p"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
            _25p: options._25p.then(|| {
-                EagerVec::forced_import(&maybe_suffix("25p"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("25p"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
            _10p: options._10p.then(|| {
-                EagerVec::forced_import(&maybe_suffix("10p"), version + Version::ZERO, compressed)
-                    .unwrap()
+                Box::new(
+                    EagerVec::forced_import(
+                        path,
+                        &maybe_suffix("10p"),
+                        version + VERSION + Version::ZERO,
+                        format,
+                    )
+                    .unwrap(),
+                )
            }),
        };

        Ok(s)
    }

-    pub fn extend(&mut self, max_from: I, source: &StoredVec<I, T>, exit: &Exit) -> Result<()> {
-        if self.total.is_none() {
+    pub fn extend(
+        &mut self,
+        max_from: I,
+        source: &impl AnyIterableVec<I, T>,
+        exit: &Exit,
+    ) -> Result<()> {
+        if self.cumulative.is_none() {
            return Ok(());
        };

+        self.validate_computed_version_or_reset_file(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 = cumulative.clone() + v.into_inner();
+            cumulative_vec.forced_push_at(i, cumulative.clone(), exit)
        })?;

        self.safe_flush(exit)?;
@@ -160,24 +233,28 @@ where
    pub fn compute<I2>(
        &mut self,
        max_from: I,
-        source: &StoredVec<I2, T>,
-        first_indexes: &StoredVec<I, I2>,
-        count_indexes: &StoredVec<I, StoredUsize>,
+        source: &impl AnyIterableVec<I2, T>,
+        first_indexes: &impl AnyIterableVec<I, I2>,
+        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
        exit: &Exit,
    ) -> Result<()>
    where
        I2: StoredIndex + StoredType + CheckedSub<I2>,
    {
+        self.validate_computed_version_or_reset_file(
+            source.version() + first_indexes.version() + count_indexes.version(),
+        )?;
+
        let index = self.starting_index(max_from);

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

@@ -186,12 +263,12 @@ where
            .try_for_each(|(i, first_index)| -> Result<()> {
                let first_index = first_index.into_inner();

-                let count_index = count_indexes_iter.get(i).unwrap().1.into_inner();
+                let count_index = count_indexes_iter.unwrap_get_inner(i);

                if let Some(first) = self.first.as_mut() {
                    let f = source_iter
-                        .get(first_index)
-                        .map_or(T::from(0_usize), |f| f.1.into_inner());
+                        .get_inner(first_index)
+                        .unwrap_or_else(|| T::from(0_usize));
                    first.forced_push_at(index, f, exit)?;
                }

@@ -201,20 +278,19 @@ where
                        panic!("should compute last if count can be 0")
                    }
                    let last_index = first_index + (count_index - 1);
-                    let v = source_iter
-                        .get(last_index)
-                        .context("to work")
-                        .inspect_err(|_| {
-                            dbg!(first_index, count_index, last_index);
-                        })
-                        .unwrap()
-                        .1
-                        .into_inner();
+                    let v = source_iter.unwrap_get_inner(last_index);
+                    // .context("to work")
+                    // .inspect_err(|_| {
+                    //     dbg!(first_index, count_index, last_index);
+                    // })
+                    // .unwrap()
+                    // .into_inner();
                    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()
@@ -222,7 +298,7 @@ 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);
@@ -244,12 +320,12 @@ where
                                        dbg!(
                                            &values,
                                            max.path(),
-                                            first_indexes.path(),
+                                            first_indexes.name(),
                                            first_index,
-                                            count_indexes.path(),
+                                            count_indexes.name(),
                                            count_index,
                                            source.len(),
-                                            source.path()
+                                            source.name()
                                        );
                                    })
                                    .unwrap()
@@ -259,23 +335,23 @@ where
                        }

                        if let Some(_90p) = self._90p.as_mut() {
-                            _90p.forced_push_at(i, Self::get_percentile(&values, 0.90), exit)?;
+                            _90p.forced_push_at(i, get_percentile(&values, 0.90), exit)?;
                        }

                        if let Some(_75p) = self._75p.as_mut() {
-                            _75p.forced_push_at(i, Self::get_percentile(&values, 0.75), exit)?;
+                            _75p.forced_push_at(i, get_percentile(&values, 0.75), exit)?;
                        }

                        if let Some(median) = self.median.as_mut() {
-                            median.forced_push_at(i, Self::get_percentile(&values, 0.50), exit)?;
+                            median.forced_push_at(i, get_percentile(&values, 0.50), exit)?;
                        }

                        if let Some(_25p) = self._25p.as_mut() {
-                            _25p.forced_push_at(i, Self::get_percentile(&values, 0.25), exit)?;
+                            _25p.forced_push_at(i, get_percentile(&values, 0.25), exit)?;
                        }

                        if let Some(_10p) = self._10p.as_mut() {
-                            _10p.forced_push_at(i, Self::get_percentile(&values, 0.10), exit)?;
+                            _10p.forced_push_at(i, get_percentile(&values, 0.10), exit)?;
                        }

                        if let Some(min) = self.min.as_mut() {
@@ -283,7 +359,7 @@ where
                        }
                    }

-                    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);

@@ -292,15 +368,15 @@ where
                            average.forced_push_at(i, 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)?;
                            }

-                            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.as_ref().unwrap().clone() + sum;
+                                cumulative.replace(t.clone());
+                                cumulative_vec.forced_push_at(i, t, exit)?;
                            }
                        }
                    }
@@ -319,8 +395,8 @@ where
        &mut self,
        max_from: I,
        source: &ComputedVecBuilder<I2, T>,
-        first_indexes: &StoredVec<I, I2>,
-        count_indexes: &StoredVec<I, StoredUsize>,
+        first_indexes: &impl AnyIterableVec<I, I2>,
+        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
        exit: &Exit,
    ) -> Result<()>
    where
@@ -335,6 +411,10 @@ where
            panic!("unsupported");
        }

+        self.validate_computed_version_or_reset_file(
+            VERSION + first_indexes.version() + count_indexes.version(),
+        )?;
+
        let index = self.starting_index(max_from);

        let mut count_indexes_iter = count_indexes.iter();
@@ -346,9 +426,9 @@ 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)
            })
        });

@@ -357,7 +437,7 @@ where
            .try_for_each(|(i, first_index, ..)| -> Result<()> {
                let first_index = first_index.into_inner();

-                let count_index = count_indexes_iter.get(i).unwrap().1.into_inner();
+                let count_index = count_indexes_iter.unwrap_get_inner(i);

                if let Some(first) = self.first.as_mut() {
                    let v = source_first_iter
@@ -380,10 +460,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 {
@@ -410,7 +491,7 @@ where
                        }
                    }

-                    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);
@@ -420,14 +501,14 @@ where
                                .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;
+                            let avg = cumulative / len;
                            average.forced_push_at(i, 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
@@ -441,10 +522,10 @@ where
                                sum_vec.forced_push_at(i, sum.clone(), 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.as_ref().unwrap().clone() + sum;
+                                cumulative.replace(t.clone());
+                                cumulative_vec.forced_push_at(i, t, exit)?;
                            }
                        }
                    }
@@ -458,109 +539,94 @@ where
        Ok(())
    }

-    fn get_percentile(sorted: &[T], percentile: f64) -> T {
-        let len = sorted.len();
-
-        if len == 0 {
-            panic!();
-        } else if len == 1 {
-            sorted[0].clone()
-        } else {
-            let index = (len - 1) as f64 * percentile;
-
-            let fract = index.fract();
-
-            if fract != 0.0 {
-                let left = sorted.get(index as usize).unwrap().clone();
-                let right = sorted.get(index.ceil() as usize).unwrap().clone();
-                left / 2 + right / 2
-            } else {
-                sorted.get(index as usize).unwrap().clone()
-            }
-        }
-    }
-
-    fn starting_index(&self, max_from: I) -> I {
+    pub fn starting_index(&self, max_from: I) -> I {
        max_from.min(I::from(
-            self.any_vecs().into_iter().map(|v| v.len()).min().unwrap(),
+            self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
        ))
    }

-    pub fn unwrap_first(&mut self) -> &mut EagerVec<I, T> {
-        self.first.as_mut().unwrap()
+    pub fn unwrap_first(&self) -> &EagerVec<I, T> {
+        self.first.as_ref().unwrap()
    }
-    pub fn unwrap_average(&mut self) -> &mut EagerVec<I, T> {
-        self.average.as_mut().unwrap()
+    #[allow(unused)]
+    pub fn unwrap_average(&self) -> &EagerVec<I, T> {
+        self.average.as_ref().unwrap()
    }
-    pub fn unwrap_sum(&mut self) -> &mut EagerVec<I, T> {
-        self.sum.as_mut().unwrap()
+    pub fn unwrap_sum(&self) -> &EagerVec<I, T> {
+        self.sum.as_ref().unwrap()
    }
-    pub fn unwrap_max(&mut self) -> &mut EagerVec<I, T> {
-        self.max.as_mut().unwrap()
+    pub fn unwrap_max(&self) -> &EagerVec<I, T> {
+        self.max.as_ref().unwrap()
    }
-    pub fn unwrap_90p(&mut self) -> &mut EagerVec<I, T> {
-        self._90p.as_mut().unwrap()
+    #[allow(unused)]
+    pub fn unwrap_90p(&self) -> &EagerVec<I, T> {
+        self._90p.as_ref().unwrap()
    }
-    pub fn unwrap_75p(&mut self) -> &mut EagerVec<I, T> {
-        self._75p.as_mut().unwrap()
+    #[allow(unused)]
+    pub fn unwrap_75p(&self) -> &EagerVec<I, T> {
+        self._75p.as_ref().unwrap()
    }
-    pub fn unwrap_median(&mut self) -> &mut EagerVec<I, T> {
-        self.median.as_mut().unwrap()
+    #[allow(unused)]
+    pub fn unwrap_median(&self) -> &EagerVec<I, T> {
+        self.median.as_ref().unwrap()
    }
-    pub fn unwrap_25p(&mut self) -> &mut EagerVec<I, T> {
-        self._25p.as_mut().unwrap()
+    #[allow(unused)]
+    pub fn unwrap_25p(&self) -> &EagerVec<I, T> {
+        self._25p.as_ref().unwrap()
    }
-    pub fn unwrap_10p(&mut self) -> &mut EagerVec<I, T> {
-        self._10p.as_mut().unwrap()
+    #[allow(unused)]
+    pub fn unwrap_10p(&self) -> &EagerVec<I, T> {
+        self._10p.as_ref().unwrap()
    }
-    pub fn unwrap_min(&mut self) -> &mut EagerVec<I, T> {
-        self.min.as_mut().unwrap()
+    pub fn unwrap_min(&self) -> &EagerVec<I, T> {
+        self.min.as_ref().unwrap()
    }
-    pub fn unwrap_last(&mut self) -> &mut EagerVec<I, T> {
-        self.last.as_mut().unwrap()
+    pub fn unwrap_last(&self) -> &EagerVec<I, T> {
+        self.last.as_ref().unwrap()
    }
-    pub fn unwrap_total(&mut self) -> &mut EagerVec<I, T> {
-        self.total.as_mut().unwrap()
+    #[allow(unused)]
+    pub fn unwrap_cumulative(&self) -> &EagerVec<I, T> {
+        self.cumulative.as_ref().unwrap()
    }

-    pub fn any_vecs(&self) -> Vec<&dyn brk_vec::AnyStoredVec> {
-        let mut v: Vec<&dyn brk_vec::AnyStoredVec> = vec![];
+    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.any_vec());
+            v.push(first.as_ref());
        }
        if let Some(last) = self.last.as_ref() {
-            v.push(last.any_vec());
+            v.push(last.as_ref());
        }
        if let Some(min) = self.min.as_ref() {
-            v.push(min.any_vec());
+            v.push(min.as_ref());
        }
        if let Some(max) = self.max.as_ref() {
-            v.push(max.any_vec());
+            v.push(max.as_ref());
        }
        if let Some(median) = self.median.as_ref() {
-            v.push(median.any_vec());
+            v.push(median.as_ref());
        }
        if let Some(average) = self.average.as_ref() {
-            v.push(average.any_vec());
+            v.push(average.as_ref());
        }
        if let Some(sum) = self.sum.as_ref() {
-            v.push(sum.any_vec());
+            v.push(sum.as_ref());
        }
-        if let Some(total) = self.total.as_ref() {
-            v.push(total.any_vec());
+        if let Some(cumulative) = self.cumulative.as_ref() {
+            v.push(cumulative.as_ref());
        }
        if let Some(_90p) = self._90p.as_ref() {
-            v.push(_90p.any_vec());
+            v.push(_90p.as_ref());
        }
        if let Some(_75p) = self._75p.as_ref() {
-            v.push(_75p.any_vec());
+            v.push(_75p.as_ref());
        }
        if let Some(_25p) = self._25p.as_ref() {
-            v.push(_25p.any_vec());
+            v.push(_25p.as_ref());
        }
        if let Some(_10p) = self._10p.as_ref() {
-            v.push(_10p.any_vec());
+            v.push(_10p.as_ref());
        }

        v
@@ -588,8 +654,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)?;
@@ -606,6 +672,47 @@ where

        Ok(())
    }
+
+    pub fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
+        if let Some(first) = self.first.as_mut() {
+            first.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(last) = self.last.as_mut() {
+            last.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(min) = self.min.as_mut() {
+            min.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(max) = self.max.as_mut() {
+            max.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(median) = self.median.as_mut() {
+            median.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(average) = self.average.as_mut() {
+            average.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(sum) = self.sum.as_mut() {
+            sum.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(cumulative) = self.cumulative.as_mut() {
+            cumulative.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_90p) = self._90p.as_mut() {
+            _90p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_75p) = self._75p.as_mut() {
+            _75p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_25p) = self._25p.as_mut() {
+            _25p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_10p) = self._10p.as_mut() {
+            _10p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+
+        Ok(())
+    }
 }

 #[derive(Default, Clone, Copy)]
@@ -621,7 +728,7 @@ pub struct StorableVecGeneatorOptions {
    min: bool,
    first: bool,
    last: bool,
-    total: bool,
+    cumulative: bool,
 }

 impl StorableVecGeneatorOptions {
@@ -645,6 +752,7 @@ impl StorableVecGeneatorOptions {
        self
    }

+    #[allow(unused)]
    pub fn add_median(mut self) -> Self {
        self.median = true;
        self
@@ -660,78 +768,92 @@ impl StorableVecGeneatorOptions {
        self
    }

+    #[allow(unused)]
    pub fn add_90p(mut self) -> Self {
        self._90p = true;
        self
    }

+    #[allow(unused)]
    pub fn add_75p(mut self) -> Self {
        self._75p = true;
        self
    }

+    #[allow(unused)]
    pub fn add_25p(mut self) -> Self {
        self._25p = true;
        self
    }

+    #[allow(unused)]
    pub fn add_10p(mut self) -> Self {
        self._10p = true;
        self
    }

-    pub fn add_total(mut self) -> Self {
-        self.total = true;
+    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_median(mut self) -> Self {
        self.median = 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_90p(mut self) -> Self {
        self._90p = false;
        self
    }

+    #[allow(unused)]
    pub fn rm_75p(mut self) -> Self {
        self._75p = false;
        self
    }

+    #[allow(unused)]
    pub fn rm_25p(mut self) -> Self {
        self._25p = false;
        self
    }

+    #[allow(unused)]
    pub fn rm_10p(mut self) -> Self {
        self._10p = false;
        self
    }

-    pub fn rm_total(mut self) -> Self {
-        self.total = false;
+    #[allow(unused)]
+    pub fn rm_cumulative(mut self) -> Self {
+        self.cumulative = false;
        self
    }

@@ -772,7 +894,7 @@ impl StorableVecGeneatorOptions {
            self.min,
            self.first,
            self.last,
-            self.total,
+            self.cumulative,
        ]
        .iter()
        .filter(|b| **b)
@@ -782,7 +904,7 @@ impl StorableVecGeneatorOptions {

    pub fn copy_self_extra(&self) -> Self {
        Self {
-            total: self.total,
+            cumulative: self.cumulative,
            ..Self::default()
        }
    }
@@ -0,0 +1,218 @@
+use std::path::Path;
+
+use brk_core::{
+    DateIndex, DecadeIndex, MonthIndex, QuarterIndex, Result, Version, WeekIndex, YearIndex,
+};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, AnyIterableVec, EagerVec, Format};
+
+use crate::vecs::{Indexes, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromDateIndex<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub dateindex: Option<EagerVec<DateIndex, T>>,
+    pub dateindex_extra: ComputedVecBuilder<DateIndex, T>,
+    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
+    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
+    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    pub yearindex: ComputedVecBuilder<YearIndex, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromDateIndex<T>
+where
+    T: ComputedType,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        format: Format,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let dateindex = compute_source.then(|| {
+            EagerVec::forced_import(path, name, version + VERSION + Version::ZERO, format).unwrap()
+        });
+
+        let dateindex_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version + VERSION + Version::ZERO,
+            format,
+            options.copy_self_extra(),
+        )?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            dateindex,
+            dateindex_extra,
+            weekindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::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(indexes, starting_indexes, exit, dateindex)
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        dateindex: Option<&impl AnyIterableVec<DateIndex, T>>,
+    ) -> color_eyre::Result<()> {
+        if let Some(dateindex) = dateindex {
+            self.dateindex_extra
+                .extend(starting_indexes.dateindex, dateindex, exit)?;
+
+            self.weekindex.compute(
+                starting_indexes.weekindex,
+                dateindex,
+                &indexes.weekindex_to_first_dateindex,
+                &indexes.weekindex_to_dateindex_count,
+                exit,
+            )?;
+
+            self.monthindex.compute(
+                starting_indexes.monthindex,
+                dateindex,
+                &indexes.monthindex_to_first_dateindex,
+                &indexes.monthindex_to_dateindex_count,
+                exit,
+            )?;
+        } else {
+            let dateindex = self.dateindex.as_ref().unwrap();
+
+            self.dateindex_extra
+                .extend(starting_indexes.dateindex, dateindex, exit)?;
+
+            self.weekindex.compute(
+                starting_indexes.weekindex,
+                dateindex,
+                &indexes.weekindex_to_first_dateindex,
+                &indexes.weekindex_to_dateindex_count,
+                exit,
+            )?;
+
+            self.monthindex.compute(
+                starting_indexes.monthindex,
+                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,
+        )?;
+
+        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.yearindex.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}
@@ -0,0 +1,253 @@
+use std::path::Path;
+
+use brk_core::{
+    DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, Result, Version,
+    WeekIndex, YearIndex,
+};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, AnyIterableVec, EagerVec, Format};
+
+use crate::vecs::{Indexes, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromHeight<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub height: Option<EagerVec<Height, T>>,
+    pub height_extra: 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>,
+    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromHeight<T>
+where
+    T: ComputedType + Ord + From<f64>,
+    f64: From<T>,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        format: Format,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let height = compute_source.then(|| {
+            EagerVec::forced_import(path, name, version + VERSION + Version::ZERO, format).unwrap()
+        });
+
+        let height_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version + VERSION + Version::ZERO,
+            format,
+            options.copy_self_extra(),
+        )?;
+
+        let dateindex = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version + VERSION + Version::ZERO,
+            format,
+            options,
+        )?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            height,
+            height_extra,
+            dateindex,
+            weekindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            difficultyepoch: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version + VERSION + Version::ZERO, format, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::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: Option<&impl AnyIterableVec<Height, T>>,
+    ) -> color_eyre::Result<()> {
+        if let Some(height) = height {
+            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,
+            )?;
+        }
+
+        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,
+        )?;
+
+        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.yearindex.vecs(),
+            // self.halvingepoch.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}
@@ -1,13 +1,13 @@
 use std::path::Path;

-use brk_core::{DifficultyEpoch, Height};
+use brk_core::{DifficultyEpoch, Height, Result, Version};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, Version};
+use brk_vec::{AnyCollectableVec, EagerVec, Format};

-use crate::storage::{ComputedType, EagerVec, Indexes, indexes};
+use crate::vecs::{Indexes, indexes};

-use super::{ComputedVecBuilder, StorableVecGeneatorOptions};
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};

 #[derive(Clone)]
 pub struct ComputedVecsFromHeightStrict<T>
@@ -31,19 +31,17 @@ where
        path: &Path,
        name: &str,
        version: Version,
-        compressed: Compressed,
+        format: Format,
        options: StorableVecGeneatorOptions,
    ) -> color_eyre::Result<Self> {
-        let version = VERSION + version;
-
        let height =
-            EagerVec::forced_import(&path.join(format!("height_to_{name}")), version, compressed)?;
+            EagerVec::forced_import(path, name, version + VERSION + Version::ZERO, format)?;

        let height_extra = ComputedVecBuilder::forced_import(
            path,
            name,
-            version,
-            compressed,
+            version + VERSION + Version::ZERO,
+            format,
            options.copy_self_extra(),
        )?;

@@ -53,9 +51,13 @@ where
            height,
            height_extra,
            difficultyepoch: ComputedVecBuilder::forced_import(
-                path, name, version, compressed, options,
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
            )?,
-            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version + VERSION + Version::ZERO, format, options)?,
        })
    }

@@ -73,26 +75,28 @@ where
        compute(&mut self.height, indexer, indexes, starting_indexes, exit)?;

        self.height_extra
-            .extend(starting_indexes.height, self.height.vec(), exit)?;
+            .extend(starting_indexes.height, &self.height, exit)?;

        self.difficultyepoch.compute(
            starting_indexes.difficultyepoch,
-            self.height.vec(),
-            indexes.difficultyepoch_to_first_height.vec(),
-            indexes.difficultyepoch_to_height_count.vec(),
+            &self.height,
+            &indexes.difficultyepoch_to_first_height,
+            &indexes.difficultyepoch_to_height_count,
            exit,
        )?;

        Ok(())
    }

-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
        [
-            vec![self.height.any_vec()],
-            self.height_extra.any_vecs(),
-            self.difficultyepoch.any_vecs(),
-            // self.halvingepoch.as_any_vecs(),
+            vec![&self.height as &dyn AnyCollectableVec],
+            self.height_extra.vecs(),
+            self.difficultyepoch.vecs(),
+            // self.halvingepoch.vecs(),
        ]
-        .concat()
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
    }
 }
@@ -0,0 +1,629 @@
+use std::path::Path;
+
+use brk_core::{
+    Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
+    Result, Sats, TxIndex, Version, WeekIndex, YearIndex,
+};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{
+    AnyCollectableVec, AnyVec, CollectableVec, EagerVec, Format, StoredIndex, VecIterator,
+};
+
+use crate::vecs::{Indexes, fetched, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromTxindex<T>
+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>,
+    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromTxindex<T>
+where
+    T: ComputedType + Ord + From<f64>,
+    f64: From<T>,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        format: Format,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let txindex = compute_source.then(|| {
+            Box::new(
+                EagerVec::forced_import(path, name, version + VERSION + Version::ZERO, format)
+                    .unwrap(),
+            )
+        });
+
+        let height = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version + VERSION + Version::ZERO,
+            format,
+            options,
+        )?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            txindex,
+            height,
+            dateindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            weekindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            difficultyepoch: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version + VERSION + Version::ZERO, format, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path,
+                name,
+                version + VERSION + Version::ZERO,
+                format,
+                options,
+            )?,
+        })
+    }
+
+    // #[allow(unused)]
+    // pub fn compute_all<F>(
+    //     &mut self,
+    //     indexer: &Indexer,
+    //     indexes: &indexes::Vecs,
+    //     starting_indexes: &Indexes,
+    //     exit: &Exit,
+    //     mut compute: F,
+    // ) -> color_eyre::Result<()>
+    // where
+    //     F: FnMut(
+    //         &mut EagerVec<TxIndex, T>,
+    //         &Indexer,
+    //         &indexes::Vecs,
+    //         &Indexes,
+    //         &Exit,
+    //     ) -> Result<()>,
+    // {
+    //     compute(
+    //         self.txindex.as_mut().unwrap(),
+    //         indexer,
+    //         indexes,
+    //         starting_indexes,
+    //         exit,
+    //     )?;
+
+    //     let txindex: Option<&StoredVec<TxIndex, T>> = None;
+    //     self.compute_rest(indexer, indexes, starting_indexes, exit, txindex)?;
+
+    //     Ok(())
+    // }
+
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        txindex: Option<&impl CollectableVec<TxIndex, T>>,
+    ) -> Result<()> {
+        if let Some(txindex) = txindex {
+            self.height.compute(
+                starting_indexes.height,
+                txindex,
+                &indexer.vecs.height_to_first_txindex,
+                &indexes.height_to_txindex_count,
+                exit,
+            )?;
+        } else {
+            let txindex = self.txindex.as_ref().unwrap().as_ref();
+
+            self.height.compute(
+                starting_indexes.height,
+                txindex,
+                &indexer.vecs.height_to_first_txindex,
+                &indexes.height_to_txindex_count,
+                exit,
+            )?;
+        }
+
+        self.compute_after_height(indexes, starting_indexes, exit)
+    }
+
+    fn compute_after_height(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.dateindex.from_aligned(
+            starting_indexes.dateindex,
+            &self.height,
+            &indexes.dateindex_to_first_height,
+            &indexes.dateindex_to_height_count,
+            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,
+            &indexes.difficultyepoch_to_first_height,
+            &indexes.difficultyepoch_to_height_count,
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.txindex
+                .as_ref()
+                .map_or(vec![], |v| vec![v.as_ref() as &dyn AnyCollectableVec]),
+            self.height.vecs(),
+            self.dateindex.vecs(),
+            self.weekindex.vecs(),
+            self.difficultyepoch.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.yearindex.vecs(),
+            // self.halvingepoch.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}
+
+impl ComputedVecsFromTxindex<Bitcoin> {
+    pub fn compute_rest_from_sats(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        sats: &ComputedVecsFromTxindex<Sats>,
+        txindex: Option<&impl CollectableVec<TxIndex, Bitcoin>>,
+    ) -> Result<()> {
+        let txindex_version = if let Some(txindex) = txindex {
+            txindex.version()
+        } else {
+            self.txindex.as_ref().unwrap().as_ref().version()
+        };
+
+        self.height
+            .validate_computed_version_or_reset_file(txindex_version)?;
+
+        let starting_index = self.height.starting_index(starting_indexes.height);
+
+        (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() {
+                    first.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_first()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(average) = self.height.average.as_mut() {
+                    average.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_average()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(sum) = self.height.sum.as_mut() {
+                    sum.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_sum()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(max) = self.height.max.as_mut() {
+                    max.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_max()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(_90p) = self.height._90p.as_mut() {
+                    _90p.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_90p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(_75p) = self.height._75p.as_mut() {
+                    _75p.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_75p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(median) = self.height.median.as_mut() {
+                    median.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_median()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(_25p) = self.height._25p.as_mut() {
+                    _25p.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_25p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(_10p) = self.height._10p.as_mut() {
+                    _10p.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_10p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(min) = self.height.min.as_mut() {
+                    min.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_min()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(last) = self.height.last.as_mut() {
+                    last.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_last()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                if let Some(cumulative) = self.height.cumulative.as_mut() {
+                    cumulative.forced_push_at(
+                        height,
+                        Bitcoin::from(
+                            sats.height
+                                .unwrap_cumulative()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        ),
+                        exit,
+                    )?;
+                }
+                Ok(())
+            })?;
+
+        self.height.safe_flush(exit)?;
+
+        self.compute_after_height(indexes, starting_indexes, exit)
+    }
+}
+
+impl ComputedVecsFromTxindex<Dollars> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute_rest_from_bitcoin(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        bitcoin: &ComputedVecsFromTxindex<Bitcoin>,
+        txindex: Option<&impl CollectableVec<TxIndex, Dollars>>,
+        fetched: &fetched::Vecs,
+    ) -> Result<()> {
+        let txindex_version = if let Some(txindex) = txindex {
+            txindex.version()
+        } else {
+            self.txindex.as_ref().unwrap().as_ref().version()
+        };
+
+        self.height
+            .validate_computed_version_or_reset_file(txindex_version)?;
+
+        let starting_index = self.height.starting_index(starting_indexes.height);
+
+        let mut close_iter = fetched.chainindexes_to_close.height.into_iter();
+
+        (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);
+
+                if let Some(first) = self.height.first.as_mut() {
+                    first.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_first()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(average) = self.height.average.as_mut() {
+                    average.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_average()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(sum) = self.height.sum.as_mut() {
+                    sum.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_sum()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(max) = self.height.max.as_mut() {
+                    max.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_max()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(_90p) = self.height._90p.as_mut() {
+                    _90p.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_90p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(_75p) = self.height._75p.as_mut() {
+                    _75p.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_75p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(median) = self.height.median.as_mut() {
+                    median.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_median()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(_25p) = self.height._25p.as_mut() {
+                    _25p.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_25p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(_10p) = self.height._10p.as_mut() {
+                    _10p.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_10p()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(min) = self.height.min.as_mut() {
+                    min.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_min()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(last) = self.height.last.as_mut() {
+                    last.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_last()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                if let Some(cumulative) = self.height.cumulative.as_mut() {
+                    cumulative.forced_push_at(
+                        height,
+                        price
+                            * bitcoin
+                                .height
+                                .unwrap_cumulative()
+                                .into_iter()
+                                .unwrap_get_inner(height),
+                        exit,
+                    )?;
+                }
+                Ok(())
+            })?;
+
+        self.height.safe_flush(exit)?;
+
+        self.compute_after_height(indexes, starting_indexes, exit)
+    }
+}
@@ -3,13 +3,21 @@ mod from_dateindex;
 mod from_height;
 mod from_height_strict;
 mod from_txindex;
+mod ratio_from_dateindex;
+mod r#type;
+mod value_from_dateindex;
 mod value_from_height;
 mod value_from_txindex;
+mod value_height;

 pub use builder::*;
 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 value_from_dateindex::*;
 pub use value_from_height::*;
 pub use value_from_txindex::*;
+pub use value_height::*;
@@ -0,0 +1,176 @@
+use std::path::Path;
+
+use brk_core::{Bitcoin, DateIndex, Dollars, Result, Sats, Version};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, CollectableVec, EagerVec, Format, StoredVec};
+
+use crate::vecs::{Indexes, fetched, grouped::ComputedVecsFromDateIndex, indexes};
+
+use super::StorableVecGeneatorOptions;
+
+#[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 {
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        format: Format,
+        options: StorableVecGeneatorOptions,
+        compute_dollars: bool,
+    ) -> color_eyre::Result<Self> {
+        Ok(Self {
+            sats: ComputedVecsFromDateIndex::forced_import(
+                path,
+                name,
+                compute_source,
+                version + VERSION,
+                format,
+                options,
+            )?,
+            bitcoin: ComputedVecsFromDateIndex::forced_import(
+                path,
+                &format!("{name}_in_btc"),
+                true,
+                version + VERSION,
+                format,
+                options,
+            )?,
+            dollars: compute_dollars.then(|| {
+                ComputedVecsFromDateIndex::forced_import(
+                    path,
+                    &format!("{name}_in_usd"),
+                    true,
+                    version + VERSION,
+                    format,
+                    options,
+                )
+                .unwrap()
+            }),
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::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, fetched, starting_indexes, exit, dateindex)?;
+
+        Ok(())
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        dateindex: Option<&impl CollectableVec<DateIndex, Sats>>,
+    ) -> color_eyre::Result<()> {
+        if let Some(dateindex) = dateindex {
+            self.sats
+                .compute_rest(indexes, 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(indexes, 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 = fetched
+            .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<_>>()
+    }
+}
@@ -1,14 +1,11 @@
 use std::path::Path;

-use brk_core::{Bitcoin, Dollars, Height, Sats};
+use brk_core::{Bitcoin, Dollars, Height, Result, Sats, Version};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, StoredVec, Version};
+use brk_vec::{AnyCollectableVec, CollectableVec, EagerVec, Format, StoredVec};

-use crate::storage::{
-    EagerVec, marketprice,
-    vecs::{Indexes, indexes},
-};
+use crate::vecs::{Indexes, fetched, indexes};

 use super::{ComputedVecsFromHeight, StorableVecGeneatorOptions};

@@ -19,7 +16,7 @@ pub struct ComputedValueVecsFromHeight {
    pub dollars: Option<ComputedVecsFromHeight<Dollars>>,
 }

-const VERSION: Version = Version::ONE;
+const VERSION: Version = Version::ZERO;

 impl ComputedValueVecsFromHeight {
    pub fn forced_import(
@@ -27,7 +24,7 @@ impl ComputedValueVecsFromHeight {
        name: &str,
        compute_source: bool,
        version: Version,
-        compressed: Compressed,
+        format: Format,
        options: StorableVecGeneatorOptions,
        compute_dollars: bool,
    ) -> color_eyre::Result<Self> {
@@ -36,16 +33,16 @@ impl ComputedValueVecsFromHeight {
                path,
                name,
                compute_source,
-                VERSION + version,
-                compressed,
+                version + VERSION,
+                format,
                options,
            )?,
            bitcoin: ComputedVecsFromHeight::forced_import(
                path,
                &format!("{name}_in_btc"),
                true,
-                VERSION + version,
-                compressed,
+                version + VERSION,
+                format,
                options,
            )?,
            dollars: compute_dollars.then(|| {
@@ -53,8 +50,8 @@ impl ComputedValueVecsFromHeight {
                    path,
                    &format!("{name}_in_usd"),
                    true,
-                    VERSION + version,
-                    compressed,
+                    version + VERSION,
+                    format,
                    options,
                )
                .unwrap()
@@ -66,7 +63,7 @@ impl ComputedValueVecsFromHeight {
        &mut self,
        indexer: &Indexer,
        indexes: &indexes::Vecs,
-        marketprices: Option<&marketprice::Vecs>,
+        fetched: Option<&fetched::Vecs>,
        starting_indexes: &Indexes,
        exit: &Exit,
        mut compute: F,
@@ -88,7 +85,8 @@ impl ComputedValueVecsFromHeight {
            exit,
        )?;

-        self.compute_rest(indexer, indexes, marketprices, starting_indexes, exit, None)?;
+        let height: Option<&StoredVec<Height, Sats>> = None;
+        self.compute_rest(indexer, indexes, fetched, starting_indexes, exit, height)?;

        Ok(())
    }
@@ -97,38 +95,47 @@ impl ComputedValueVecsFromHeight {
        &mut self,
        indexer: &Indexer,
        indexes: &indexes::Vecs,
-        marketprices: Option<&marketprice::Vecs>,
+        fetched: Option<&fetched::Vecs>,
        starting_indexes: &Indexes,
        exit: &Exit,
-        height: Option<&StoredVec<Height, Sats>>,
+        height: Option<&impl CollectableVec<Height, Sats>>,
    ) -> color_eyre::Result<()> {
-        if let Some(height) = height.as_ref() {
+        if let Some(height) = height {
            self.sats
                .compute_rest(indexes, starting_indexes, exit, Some(height))?;
+
+            self.bitcoin.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_sats(starting_indexes.height, height, exit)
+                },
+            )?;
        } else {
+            let height: Option<&StoredVec<Height, Sats>> = None;
+
            self.sats
-                .compute_rest(indexes, starting_indexes, exit, None)?;
+                .compute_rest(indexes, starting_indexes, exit, height)?;
+
+            self.bitcoin.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_sats(
+                        starting_indexes.height,
+                        self.sats.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
        }

-        let height = height.unwrap_or_else(|| self.sats.height.as_ref().unwrap().vec());
-
-        self.bitcoin.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_from_sats(starting_indexes.height, height, exit)
-            },
-        )?;
-
-        let txindex = self.bitcoin.height.as_ref().unwrap().vec();
-        let price = marketprices
-            .as_ref()
-            .unwrap()
-            .chainindexes_to_close
-            .height
-            .vec();
+        let height_to_bitcoin = self.bitcoin.height.as_ref().unwrap();
+        let height_to_close = &fetched.as_ref().unwrap().chainindexes_to_close.height;

        if let Some(dollars) = self.dollars.as_mut() {
            dollars.compute_all(
@@ -137,7 +144,12 @@ impl ComputedValueVecsFromHeight {
                starting_indexes,
                exit,
                |v, _, _, starting_indexes, exit| {
-                    v.compute_from_bitcoin(starting_indexes.height, txindex, price, exit)
+                    v.compute_from_bitcoin(
+                        starting_indexes.height,
+                        height_to_bitcoin,
+                        height_to_close,
+                        exit,
+                    )
                },
            )?;
        }
@@ -145,12 +157,14 @@ impl ComputedValueVecsFromHeight {
        Ok(())
    }

-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
        [
-            self.sats.any_vecs(),
-            self.bitcoin.any_vecs(),
-            self.dollars.as_ref().map_or(vec![], |v| v.any_vecs()),
+            self.sats.vecs(),
+            self.bitcoin.vecs(),
+            self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
        ]
-        .concat()
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
    }
 }
@@ -0,0 +1,240 @@
+use std::path::Path;
+
+use brk_core::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{
+    AnyCollectableVec, BoxedAnyIterableVec, CloneableAnyIterableVec, CollectableVec, Computation,
+    ComputedVecFrom3, Format, LazyVecFrom1, StoredIndex, StoredVec,
+};
+
+use crate::vecs::{Indexes, fetched, indexes};
+
+use super::{ComputedVecsFromTxindex, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedValueVecsFromTxindex {
+    pub sats: ComputedVecsFromTxindex<Sats>,
+    pub bitcoin_txindex: LazyVecFrom1<TxIndex, Bitcoin, TxIndex, Sats>,
+    pub bitcoin: ComputedVecsFromTxindex<Bitcoin>,
+    #[allow(clippy::type_complexity)]
+    pub dollars_txindex: Option<
+        ComputedVecFrom3<
+            TxIndex,
+            Dollars,
+            TxIndex,
+            Bitcoin,
+            TxIndex,
+            Height,
+            Height,
+            Close<Dollars>,
+        >,
+    >,
+    pub dollars: Option<ComputedVecsFromTxindex<Dollars>>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl ComputedValueVecsFromTxindex {
+    #[allow(clippy::too_many_arguments)]
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        indexes: &indexes::Vecs,
+        source: Option<BoxedAnyIterableVec<TxIndex, Sats>>,
+        version: Version,
+        computation: Computation,
+        format: Format,
+        fetched: Option<&fetched::Vecs>,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let compute_source = source.is_none();
+        let compute_dollars = fetched.is_some();
+
+        let name_in_btc = format!("{name}_in_btc");
+        let name_in_usd = format!("{name}_in_usd");
+
+        let sats = ComputedVecsFromTxindex::forced_import(
+            path,
+            name,
+            compute_source,
+            version + VERSION,
+            format,
+            options,
+        )?;
+
+        let bitcoin_txindex = LazyVecFrom1::init(
+            &name_in_btc,
+            version + VERSION,
+            source.map_or_else(|| sats.txindex.as_ref().unwrap().boxed_clone(), |s| s),
+            |txindex: TxIndex, iter| {
+                iter.next_at(txindex.unwrap_to_usize()).map(|(_, value)| {
+                    let sats = value.into_inner();
+                    Bitcoin::from(sats)
+                })
+            },
+        );
+
+        let bitcoin = ComputedVecsFromTxindex::forced_import(
+            path,
+            &name_in_btc,
+            false,
+            version + VERSION,
+            format,
+            options,
+        )?;
+
+        let dollars_txindex = fetched.map(|fetched| {
+            ComputedVecFrom3::forced_import_or_init_from_3(
+                computation,
+                path,
+                &name_in_usd,
+                version + VERSION,
+                format,
+                bitcoin_txindex.boxed_clone(),
+                indexes.txindex_to_height.boxed_clone(),
+                fetched.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();
+                        txindex_to_height_iter
+                            .next_at(txindex)
+                            .and_then(|(_, value)| {
+                                let height = value.into_inner();
+                                height_to_close_iter
+                                    .next_at(height.unwrap_to_usize())
+                                    .map(|(_, close)| *close.into_inner() * btc)
+                            })
+                    })
+                },
+            )
+            .unwrap()
+        });
+
+        Ok(Self {
+            sats,
+            bitcoin_txindex,
+            bitcoin,
+            dollars_txindex,
+            dollars: compute_dollars.then(|| {
+                ComputedVecsFromTxindex::forced_import(
+                    path,
+                    &name_in_usd,
+                    false,
+                    version + VERSION,
+                    format,
+                    options,
+                )
+                .unwrap()
+            }),
+        })
+    }
+
+    // pub fn compute_all<F>(
+    //     &mut self,
+    //     indexer: &Indexer,
+    //     indexes: &indexes::Vecs,
+    //     fetched: Option<&marketprice::Vecs>,
+    //     starting_indexes: &Indexes,
+    //     exit: &Exit,
+    //     mut compute: F,
+    // ) -> color_eyre::Result<()>
+    // where
+    //     F: FnMut(
+    //         &mut EagerVec<TxIndex, Sats>,
+    //         &Indexer,
+    //         &indexes::Vecs,
+    //         &Indexes,
+    //         &Exit,
+    //     ) -> Result<()>,
+    // {
+    //     compute(
+    //         self.sats.txindex.as_mut().unwrap(),
+    //         indexer,
+    //         indexes,
+    //         starting_indexes,
+    //         exit,
+    //     )?;
+
+    //     let txindex: Option<&StoredVec<TxIndex, Sats>> = None;
+    //     self.compute_rest(
+    //         indexer,
+    //         indexes,
+    //         fetched,
+    //         starting_indexes,
+    //         exit,
+    //         txindex,
+    //     )?;
+
+    //     Ok(())
+    // }
+
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        txindex: Option<&impl CollectableVec<TxIndex, Sats>>,
+        fetched: Option<&fetched::Vecs>,
+    ) -> color_eyre::Result<()> {
+        if let Some(txindex) = txindex {
+            self.sats
+                .compute_rest(indexer, indexes, starting_indexes, exit, Some(txindex))?;
+        } else {
+            let txindex: Option<&StoredVec<TxIndex, Sats>> = None;
+            self.sats
+                .compute_rest(indexer, indexes, starting_indexes, exit, txindex)?;
+        }
+
+        self.bitcoin.compute_rest_from_sats(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            &self.sats,
+            Some(&self.bitcoin_txindex),
+        )?;
+
+        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,
+                &indexer.vecs.txindex_to_txid,
+                exit,
+            )?;
+
+            dollars.compute_rest_from_bitcoin(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                &self.bitcoin,
+                Some(dollars_txindex),
+                fetched.as_ref().unwrap(),
+            )?;
+        }
+
+        Ok(())
+    }
+
+    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()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}
@@ -0,0 +1,126 @@
+use std::path::Path;
+
+use brk_core::{Bitcoin, Dollars, Height, Result, Sats, Version};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, CollectableVec, EagerVec, Format, StoredVec};
+
+use crate::vecs::{Indexes, fetched, indexes};
+
+#[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(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        format: Format,
+        compute_dollars: bool,
+    ) -> color_eyre::Result<Self> {
+        Ok(Self {
+            sats: compute_source.then(|| {
+                EagerVec::forced_import(path, name, version + VERSION + Version::ZERO, format)
+                    .unwrap()
+            }),
+            bitcoin: EagerVec::forced_import(
+                path,
+                &format!("{name}_in_btc"),
+                version + VERSION + Version::ZERO,
+                format,
+            )?,
+            dollars: compute_dollars.then(|| {
+                EagerVec::forced_import(
+                    path,
+                    &format!("{name}_in_usd"),
+                    version + VERSION + Version::ZERO,
+                    format,
+                )
+                .unwrap()
+            }),
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::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(fetched, starting_indexes, exit, height)?;
+
+        Ok(())
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        fetched: Option<&fetched::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        height: Option<&impl CollectableVec<Height, Sats>>,
+    ) -> color_eyre::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 = &fetched.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<_>>()
+    }
+}
@@ -1,48 +1,55 @@
-use std::{fs, path::Path};
+use std::path::Path;

-use brk_core::{DifficultyEpoch, HalvingEpoch, StoredF64};
+use brk_core::{DifficultyEpoch, HalvingEpoch, StoredF64, Version};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{Compressed, Version};
+use brk_vec::{AnyCollectableVec, Computation, Format, VecIterator};

 use super::{
    Indexes,
-    grouped::{ComputedVecsFromDateindex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    grouped::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
    indexes,
 };

+const VERSION: Version = Version::ZERO;
+
 #[derive(Clone)]
 pub struct Vecs {
    pub indexes_to_difficulty: ComputedVecsFromHeight<StoredF64>,
-    pub indexes_to_difficultyepoch: ComputedVecsFromDateindex<DifficultyEpoch>,
-    pub indexes_to_halvingepoch: ComputedVecsFromDateindex<HalvingEpoch>,
+    pub indexes_to_difficultyepoch: ComputedVecsFromDateIndex<DifficultyEpoch>,
+    pub indexes_to_halvingepoch: ComputedVecsFromDateIndex<HalvingEpoch>,
 }

 impl Vecs {
-    pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
+    pub fn forced_import(
+        path: &Path,
+        version: Version,
+        _computation: Computation,
+        format: Format,
+    ) -> color_eyre::Result<Self> {
        Ok(Self {
            indexes_to_difficulty: ComputedVecsFromHeight::forced_import(
                path,
                "difficulty",
                false,
-                Version::ZERO,
-                compressed,
+                version + VERSION + Version::ZERO,
+                format,
                StorableVecGeneatorOptions::default().add_last(),
            )?,
-            indexes_to_difficultyepoch: ComputedVecsFromDateindex::forced_import(
+            indexes_to_difficultyepoch: ComputedVecsFromDateIndex::forced_import(
                path,
                "difficultyepoch",
-                Version::ZERO,
-                compressed,
+                true,
+                version + VERSION + Version::ZERO,
+                format,
                StorableVecGeneatorOptions::default().add_last(),
            )?,
-            indexes_to_halvingepoch: ComputedVecsFromDateindex::forced_import(
+            indexes_to_halvingepoch: ComputedVecsFromDateIndex::forced_import(
                path,
                "halvingepoch",
-                Version::ZERO,
-                compressed,
+                true,
+                version + VERSION + Version::ZERO,
+                format,
                StorableVecGeneatorOptions::default().add_last(),
            )?,
        })
@@ -55,17 +62,17 @@ impl Vecs {
        starting_indexes: &Indexes,
        exit: &Exit,
    ) -> color_eyre::Result<()> {
-        let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.iter();
-        self.indexes_to_difficultyepoch.compute(
+        let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.into_iter();
+        self.indexes_to_difficultyepoch.compute_all(
            indexer,
            indexes,
            starting_indexes,
            exit,
            |vec, _, indexes, starting_indexes, exit| {
-                let mut height_count_iter = indexes.dateindex_to_height_count.iter();
+                let mut height_count_iter = indexes.dateindex_to_height_count.into_iter();
                vec.compute_transform(
                    starting_indexes.dateindex,
-                    indexes.dateindex_to_first_height.vec(),
+                    &indexes.dateindex_to_first_height,
                    |(di, height, ..)| {
                        (
                            di,
@@ -79,17 +86,17 @@ impl Vecs {
            },
        )?;

-        let mut height_to_halvingepoch_iter = indexes.height_to_halvingepoch.iter();
-        self.indexes_to_halvingepoch.compute(
+        let mut height_to_halvingepoch_iter = indexes.height_to_halvingepoch.into_iter();
+        self.indexes_to_halvingepoch.compute_all(
            indexer,
            indexes,
            starting_indexes,
            exit,
            |vec, _, indexes, starting_indexes, exit| {
-                let mut height_count_iter = indexes.dateindex_to_height_count.iter();
+                let mut height_count_iter = indexes.dateindex_to_height_count.into_iter();
                vec.compute_transform(
                    starting_indexes.dateindex,
-                    indexes.dateindex_to_first_height.vec(),
+                    &indexes.dateindex_to_first_height,
                    |(di, height, ..)| {
                        (
                            di,
@@ -107,18 +114,20 @@ impl Vecs {
            indexes,
            starting_indexes,
            exit,
-            Some(indexer.vecs().height_to_difficulty.vec()),
+            Some(&indexer.vecs.height_to_difficulty),
        )?;

        Ok(())
    }

-    pub fn as_any_vecs(&self) -> Vec<&dyn brk_vec::AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
        [
-            self.indexes_to_difficulty.any_vecs(),
-            self.indexes_to_difficultyepoch.any_vecs(),
-            self.indexes_to_halvingepoch.any_vecs(),
+            self.indexes_to_difficulty.vecs(),
+            self.indexes_to_difficultyepoch.vecs(),
+            self.indexes_to_halvingepoch.vecs(),
        ]
-        .concat()
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
    }
 }
@@ -0,0 +1,212 @@
+use std::path::Path;
+
+use brk_core::Version;
+use brk_exit::Exit;
+use brk_fetcher::Fetcher;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, Computation, Format};
+
+pub mod blocks;
+pub mod cointime;
+pub mod constants;
+pub mod fetched;
+pub mod grouped;
+pub mod indexes;
+pub mod market;
+pub mod mining;
+pub mod stateful;
+pub mod transactions;
+
+pub use indexes::Indexes;
+use log::info;
+
+const VERSION: Version = Version::ONE;
+
+#[derive(Clone)]
+pub struct Vecs {
+    pub indexes: indexes::Vecs,
+    pub constants: constants::Vecs,
+    pub blocks: blocks::Vecs,
+    pub mining: mining::Vecs,
+    pub market: market::Vecs,
+    pub transactions: transactions::Vecs,
+    pub stateful: stateful::Vecs,
+    pub fetched: Option<fetched::Vecs>,
+    pub cointime: cointime::Vecs,
+}
+
+impl Vecs {
+    pub fn import(
+        path: &Path,
+        version: Version,
+        indexer: &Indexer,
+        fetch: bool,
+        computation: Computation,
+        format: Format,
+    ) -> color_eyre::Result<Self> {
+        let indexes = indexes::Vecs::forced_import(
+            path,
+            version + VERSION + Version::ZERO,
+            indexer,
+            computation,
+            format,
+        )?;
+
+        let fetched = fetch.then(|| {
+            fetched::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+            )
+            .unwrap()
+        });
+
+        Ok(Self {
+            blocks: blocks::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+            )?,
+            mining: mining::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+            )?,
+            constants: constants::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+            )?,
+            market: market::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+            )?,
+            stateful: stateful::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+                fetched.as_ref(),
+            )?,
+            transactions: transactions::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                indexer,
+                &indexes,
+                computation,
+                format,
+                fetched.as_ref(),
+            )?,
+            cointime: cointime::Vecs::forced_import(
+                path,
+                version + VERSION + Version::ZERO,
+                computation,
+                format,
+                fetched.as_ref(),
+            )?,
+            indexes,
+            fetched,
+        })
+    }
+
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        starting_indexes: brk_indexer::Indexes,
+        fetcher: Option<&mut Fetcher>,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        info!("Computing indexes...");
+        let mut starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
+
+        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,
+                fetcher.unwrap(),
+                exit,
+            )?;
+        }
+
+        info!("Computing transactions...");
+        self.transactions.compute(
+            indexer,
+            &self.indexes,
+            &starting_indexes,
+            self.fetched.as_ref(),
+            exit,
+        )?;
+
+        if let Some(fetched) = self.fetched.as_ref() {
+            info!("Computing market...");
+            self.market.compute(
+                indexer,
+                &self.indexes,
+                fetched,
+                &mut self.transactions,
+                &starting_indexes,
+                exit,
+            )?;
+        }
+
+        info!("Computing stateful...");
+        self.stateful.compute(
+            indexer,
+            &self.indexes,
+            &self.transactions,
+            self.fetched.as_ref(),
+            &self.market,
+            &mut starting_indexes,
+            exit,
+        )?;
+
+        self.cointime.compute(
+            indexer,
+            &self.indexes,
+            &starting_indexes,
+            self.fetched.as_ref(),
+            &self.transactions,
+            &self.stateful,
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            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()),
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+    }
+}
@@ -0,0 +1,258 @@
+use std::{collections::BTreeMap, ops::ControlFlow};
+
+use brk_core::{CheckedSub, Dollars, HalvingEpoch, Height, Result, Timestamp};
+use brk_exit::Exit;
+use brk_state::{BlockState, OutputFilter, Outputs, Transacted};
+use brk_vec::StoredIndex;
+use rayon::prelude::*;
+
+use crate::vecs::Indexes;
+
+use super::cohort;
+
+pub trait OutputCohorts {
+    fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp);
+    fn send(&mut self, height_to_sent: BTreeMap<Height, Transacted>, chain_state: &[BlockState]);
+    fn receive(&mut self, received: Transacted, height: Height, price: Option<Dollars>);
+    fn compute_overlapping_vecs(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()>;
+}
+
+impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
+    fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp) {
+        if chain_state.is_empty() {
+            return;
+        }
+
+        let prev_timestamp = chain_state.last().unwrap().timestamp;
+
+        self.by_date_range
+            .as_mut_vec()
+            .into_par_iter()
+            .for_each(|(filter, v)| {
+                let state = &mut v.state;
+
+                let _ = chain_state
+                    .iter()
+                    .try_for_each(|block_state| -> ControlFlow<()> {
+                        let prev_days_old = block_state
+                            .timestamp
+                            .difference_in_days_between(prev_timestamp);
+                        let days_old = block_state.timestamp.difference_in_days_between(timestamp);
+
+                        if prev_days_old == days_old {
+                            return ControlFlow::Continue(());
+                        }
+
+                        let is = filter.contains(days_old);
+                        let was = filter.contains(prev_days_old);
+
+                        if is && !was {
+                            state.increment(&block_state.supply, block_state.price);
+                        } else if was && !is {
+                            state.decrement(&block_state.supply, block_state.price);
+                        }
+
+                        ControlFlow::Continue(())
+                    });
+            });
+    }
+
+    fn send(&mut self, height_to_sent: BTreeMap<Height, Transacted>, chain_state: &[BlockState]) {
+        let mut time_based_vecs = self
+            .by_date_range
+            .as_mut_vec()
+            .into_iter()
+            .chain(self.by_epoch.as_mut_vec())
+            .collect::<Vec<_>>();
+
+        let last_timestamp = chain_state.last().unwrap().timestamp;
+        let current_price = chain_state.last().unwrap().price;
+
+        // dbg!(&height_to_sent);
+
+        height_to_sent.into_iter().for_each(|(height, sent)| {
+            let block_state = chain_state.get(height.unwrap_to_usize()).unwrap();
+            let prev_price = block_state.price;
+
+            let blocks_old = chain_state.len() - 1 - height.unwrap_to_usize();
+
+            let days_old = block_state
+                .timestamp
+                .difference_in_days_between(last_timestamp);
+
+            let days_old_foat = block_state
+                .timestamp
+                .difference_in_days_between_float(last_timestamp);
+
+            let older_than_hour =
+                jiff::Timestamp::from(last_timestamp.checked_sub(block_state.timestamp).unwrap())
+                    .as_second()
+                    >= 60 * 60;
+
+            time_based_vecs
+                .iter_mut()
+                .filter(|(filter, _)| match filter {
+                    OutputFilter::From(from) => *from <= days_old,
+                    OutputFilter::To(to) => *to > days_old,
+                    OutputFilter::Range(range) => range.contains(&days_old),
+                    OutputFilter::Epoch(epoch) => *epoch == HalvingEpoch::from(height),
+                    _ => unreachable!(),
+                })
+                .for_each(|(_, vecs)| {
+                    vecs.state.send(
+                        &sent.spendable_supply,
+                        current_price,
+                        prev_price,
+                        blocks_old,
+                        days_old_foat,
+                        older_than_hour,
+                    );
+                });
+
+            sent.by_type.spendable.as_typed_vec().into_iter().for_each(
+                |(output_type, supply_state)| {
+                    self.by_type.get_mut(output_type).1.state.send(
+                        supply_state,
+                        current_price,
+                        prev_price,
+                        blocks_old,
+                        days_old_foat,
+                        older_than_hour,
+                    )
+                },
+            );
+
+            sent.by_size_group
+                .into_iter()
+                .for_each(|(group, supply_state)| {
+                    self.by_size_range.get_mut(group).1.state.send(
+                        &supply_state,
+                        current_price,
+                        prev_price,
+                        blocks_old,
+                        days_old_foat,
+                        older_than_hour,
+                    );
+                });
+        });
+    }
+
+    fn receive(&mut self, received: Transacted, height: Height, price: Option<Dollars>) {
+        let supply_state = received.spendable_supply;
+
+        [
+            &mut self.by_date_range.start_to_1d.1,
+            &mut self.by_epoch.mut_vec_from_height(height).1,
+        ]
+        .into_iter()
+        .for_each(|v| {
+            v.state.receive(&supply_state, price);
+        });
+
+        self.by_type
+            .as_mut_vec()
+            .into_iter()
+            .for_each(|(filter, vecs)| {
+                let output_type = match filter {
+                    OutputFilter::Type(output_type) => *output_type,
+                    _ => unreachable!(),
+                };
+                vecs.state.receive(received.by_type.get(output_type), price)
+            });
+
+        received
+            .by_size_group
+            .into_iter()
+            .for_each(|(group, supply_state)| {
+                self.by_size_range
+                    .get_mut(group)
+                    .1
+                    .state
+                    .receive(&supply_state, price);
+            });
+    }
+
+    fn compute_overlapping_vecs(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()> {
+        let by_date_range = self.by_date_range.as_vec();
+        let by_size_range = self.by_size_range.as_vec();
+
+        [
+            vec![(&mut self.all.1, self.by_epoch.vecs().to_vec())],
+            self.by_from_date
+                .as_mut_vec()
+                .into_iter()
+                .map(|(filter, vecs)| {
+                    (
+                        vecs,
+                        by_date_range
+                            .into_iter()
+                            .filter(|(other, _)| filter.includes(other))
+                            .map(|(_, v)| v)
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .collect::<Vec<_>>(),
+            self.by_up_to_date
+                .as_mut_vec()
+                .into_iter()
+                .map(|(filter, vecs)| {
+                    (
+                        vecs,
+                        by_date_range
+                            .into_iter()
+                            .filter(|(other, _)| filter.includes(other))
+                            .map(|(_, v)| v)
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .collect::<Vec<_>>(),
+            self.by_term
+                .as_mut_vec()
+                .into_iter()
+                .map(|(filter, vecs)| {
+                    (
+                        vecs,
+                        by_date_range
+                            .into_iter()
+                            .filter(|(other, _)| filter.includes(other))
+                            .map(|(_, v)| v)
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .collect::<Vec<_>>(),
+            self.by_from_size
+                .as_mut_vec()
+                .into_iter()
+                .map(|(filter, vecs)| {
+                    (
+                        vecs,
+                        by_size_range
+                            .into_iter()
+                            .filter(|(other, _)| filter.includes(other))
+                            .map(|(_, v)| v)
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .collect::<Vec<_>>(),
+            self.by_up_to_size
+                .as_mut_vec()
+                .into_iter()
+                .map(|(filter, vecs)| {
+                    (
+                        vecs,
+                        by_size_range
+                            .into_iter()
+                            .filter(|(other, _)| filter.includes(other))
+                            .map(|(_, v)| v)
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .collect::<Vec<_>>(),
+        ]
+        .into_par_iter()
+        .flatten()
+        .try_for_each(|(vecs, stateful)| {
+            vecs.compute_from_stateful(starting_indexes, &stateful, exit)
+        })
+    }
+}
@@ -4,20 +4,25 @@ description = "The Core (Structs and Errors) of the Bitcoin Research Kit"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
+homepage.workspace = true
 repository.workspace = true

 [dependencies]
+bincode = { workspace = true }
 bitcoin = { workspace = true }
 bitcoincore-rpc = { workspace = true }
 byteview = { workspace = true }
 derive_deref = { workspace = true }
+fjall = { workspace = true }
 jiff = { workspace = true }
 log = { workspace = true }
 rapidhash = "1.4.0"
 rlimit = "0.10.2"
 serde = { workspace = true }
-serde_bytes = "0.11.17"
+serde_bytes = { workspace = true }
+serde_json = { workspace = true }
 zerocopy = { workspace = true }
+zerocopy-derive = { workspace = true }

 [package.metadata.cargo-machete]
 ignored = ["serde_bytes"]
@@ -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>
@@ -1,19 +1,27 @@
 use std::{
    fmt::{self, Debug},
-    io,
+    io, result, time,
 };

 use crate::Version;

-pub type Result<T, E = Error> = std::result::Result<T, E>;
+pub type Result<T, E = Error> = result::Result<T, E>;

 #[derive(Debug)]
 pub enum Error {
+    IO(io::Error),
+    SerdeJson(serde_json::Error),
+    Jiff(jiff::Error),
+    Fjall(fjall::Error),
+    SystemTimeError(time::SystemTimeError),
+    ZeroCopyError,
+    BincodeEncodeError(bincode::error::EncodeError),
+    BincodeDecodeError(bincode::error::DecodeError),
+
    WrongEndian,
    DifferentVersion { found: Version, expected: Version },
+    UnexpectedData,
    MmapsVecIsTooSmall,
-    IO(io::Error),
-    ZeroCopyError,
    IndexTooHigh,
    EmptyVec,
    IndexTooLow,
@@ -23,7 +31,17 @@ pub enum Error {
    UnsupportedUnflushedState,
    RangeFromAfterTo(usize, usize),
    DifferentCompressionMode,
-    ToSerdeJsonValueError(serde_json::Error),
+    WrongLength,
+    WrongAddressType,
+    UnindexableDate,
+
+    String(&'static str),
+}
+
+impl From<time::SystemTimeError> for Error {
+    fn from(value: time::SystemTimeError) -> Self {
+        Self::SystemTimeError(value)
+    }
 }

 impl From<io::Error> for Error {
@@ -32,6 +50,18 @@ impl From<io::Error> for Error {
    }
 }

+impl From<jiff::Error> for Error {
+    fn from(value: jiff::Error) -> Self {
+        Self::Jiff(value)
+    }
+}
+
+impl From<fjall::Error> for Error {
+    fn from(value: fjall::Error) -> Self {
+        Self::Fjall(value)
+    }
+}
+
 impl<A, B, C> From<zerocopy::error::ConvertError<A, B, C>> for Error {
    fn from(_: zerocopy::error::ConvertError<A, B, C>) -> Self {
        Self::ZeroCopyError
@@ -46,22 +76,43 @@ impl<A, B> From<zerocopy::error::SizeError<A, B>> for Error {

 impl From<serde_json::Error> for Error {
    fn from(error: serde_json::Error) -> Self {
-        Self::ToSerdeJsonValueError(error)
+        Self::SerdeJson(error)
+    }
+}
+
+impl From<bincode::error::DecodeError> for Error {
+    fn from(error: bincode::error::DecodeError) -> Self {
+        Self::BincodeDecodeError(error)
+    }
+}
+
+impl From<bincode::error::EncodeError> for Error {
+    fn from(error: bincode::error::EncodeError) -> Self {
+        Self::BincodeEncodeError(error)
    }
 }

 impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
+            Error::IO(error) => Debug::fmt(&error, f),
+            Error::SystemTimeError(error) => Debug::fmt(&error, f),
+            Error::SerdeJson(error) => Debug::fmt(&error, f),
+            Error::Jiff(error) => Debug::fmt(&error, f),
+            Error::Fjall(error) => Debug::fmt(&error, f),
+            Error::BincodeDecodeError(error) => Debug::fmt(&error, f),
+            Error::BincodeEncodeError(error) => Debug::fmt(&error, f),
+            Error::ZeroCopyError => write!(f, "ZeroCopy error"),
+            Error::UnexpectedData => write!(f, "Unexpected data"),
+
            Error::WrongEndian => write!(f, "Wrong endian"),
            Error::DifferentVersion { found, expected } => {
                write!(
                    f,
-                    "Different version; found: {found:?}, expected: {expected:?}"
+                    "Different version found: {found:?}, expected: {expected:?}"
                )
            }
            Error::MmapsVecIsTooSmall => write!(f, "Mmaps vec is too small"),
-            Error::IO(error) => Debug::fmt(&error, f),
            Error::IndexTooHigh => write!(f, "Index too high"),
            Error::IndexTooLow => write!(f, "Index too low"),
            Error::ExpectFileToHaveIndex => write!(f, "Expect file to have index"),
@@ -73,11 +124,17 @@ impl fmt::Display for Error {
                    "Unsupported unflush state, please flush before using this function"
                )
            }
-            Error::ZeroCopyError => write!(f, "Zero copy convert error"),
            Error::RangeFromAfterTo(from, to) => write!(f, "Range, from {from} is after to {to}"),
            Error::DifferentCompressionMode => write!(f, "Different compression mode chosen"),
            Error::EmptyVec => write!(f, "The Vec is empty, maybe wait for a bit"),
-            Error::ToSerdeJsonValueError(error) => Debug::fmt(&error, f),
+            Error::WrongLength => write!(f, "Wrong length"),
+            Error::WrongAddressType => write!(f, "Wrong address type"),
+            Error::UnindexableDate => write!(
+                f,
+                "Date cannot be indexed, must be 2009-01-03, 2009-01-09 or greater"
+            ),
+
+            Error::String(s) => write!(f, "{s}"),
        }
    }
 }
@@ -1,49 +0,0 @@
-use std::{
-    fmt::{self, Debug},
-    io,
-};
-
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
-#[derive(Debug)]
-pub enum Error {
-    IO(io::Error),
-    Jiff(jiff::Error),
-    ZeroCopyError,
-    WrongLength,
-    WrongAddressType,
-    UnindexableDate,
-}
-
-impl From<io::Error> for Error {
-    fn from(value: io::Error) -> Self {
-        Self::IO(value)
-    }
-}
-
-impl From<jiff::Error> for Error {
-    fn from(value: jiff::Error) -> Self {
-        Self::Jiff(value)
-    }
-}
-
-impl<A, B> From<zerocopy::error::SizeError<A, B>> for Error {
-    fn from(_: zerocopy::error::SizeError<A, B>) -> Self {
-        Self::ZeroCopyError
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::IO(error) => Debug::fmt(&error, f),
-            Error::Jiff(error) => Debug::fmt(&error, f),
-            Error::ZeroCopyError => write!(f, "Zero copy convert error"),
-            Error::WrongLength => write!(f, "Wrong length"),
-            Error::WrongAddressType => write!(f, "Wrong address type"),
-            Error::UnindexableDate => write!(f, "Date cannot be indexed, must be 2009-01-03, 2009-01-09 or greater"),
-        }
-    }
-}
-
-impl std::error::Error for Error {}
@@ -1,9 +1,11 @@
 #![doc = include_str!("../README.md")]

-mod error;
+mod enums;
 mod structs;
+mod traits;
 mod utils;

-pub use error::*;
+pub use enums::*;
 pub use structs::*;
+pub use traits::*;
 pub use utils::*;
@@ -2,7 +2,7 @@ use std::ops::Add;

 use byteview::ByteView;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

 use crate::Error;

@@ -63,9 +63,8 @@ impl From<AddressIndex> for usize {
    }
 }

-impl TryFrom<ByteView> for AddressIndex {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+impl From<ByteView> for AddressIndex {
+    fn from(value: ByteView) -> Self {
        Ok(Self::read_from_bytes(&value)?)
    }
 }
@@ -1,5 +1,5 @@
 use byteview::ByteView;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

 use crate::Error;

@@ -15,9 +15,8 @@ pub struct AddressIndexOutputIndex {
    outputindex: Outputindex,
 }

-impl TryFrom<ByteView> for AddressIndexOutputIndex {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+impl From<ByteView> for AddressIndexOutputIndex {
+    fn from(value: ByteView) -> Self {
        Ok(Self::read_from_bytes(&value)?)
    }
 }
@@ -1,5 +1,5 @@
 use serde::Serialize;
-use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+use zerocopy_derive::{Immutable, IntoBytes, KnownLayout, TryFromBytes};

 use super::OutputType;

@@ -8,7 +8,7 @@ use bitcoin::{
 };
 use derive_deref::{Deref, DerefMut};
 use serde::{Serialize, Serializer};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

 use crate::Error;

@@ -2,9 +2,8 @@ use std::hash::Hasher;

 use byteview::ByteView;
 use derive_deref::Deref;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use crate::Error;
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

 use super::{AddressBytes, OutputType};

@@ -40,10 +39,9 @@ impl From<[u8; 8]> for AddressBytesHash {
    }
 }

-impl TryFrom<ByteView> for AddressBytesHash {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
+impl From<ByteView> for AddressBytesHash {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
    }
 }

@@ -1,23 +1,16 @@
-use std::ops::{Add, Div, Mul};
+use std::{
+    cmp::Ordering,
+    ops::{Add, Div, Mul},
+};

 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use super::Sats;
+use crate::CheckedSub;

-#[derive(
-    Debug,
-    Default,
-    Clone,
-    Copy,
-    PartialEq,
-    PartialOrd,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
+use super::{Sats, StoredF64};
+
+#[derive(Debug, Default, Clone, Copy, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize)]
 pub struct Bitcoin(f64);

 impl Add for Bitcoin {
@@ -34,6 +27,21 @@ impl Mul for Bitcoin {
    }
 }

+impl Mul<usize> for Bitcoin {
+    type Output = Self;
+    fn mul(self, rhs: usize) -> Self::Output {
+        Self::from(Sats::from(self) * rhs)
+    }
+}
+
+impl Div<Bitcoin> for Bitcoin {
+    type Output = StoredF64;
+    fn div(self, rhs: Bitcoin) -> Self::Output {
+        StoredF64::from(self.0 / rhs.0)
+        // Self::from(Sats::from(self) / Sats::from(rhs))
+    }
+}
+
 impl Div<usize> for Bitcoin {
    type Output = Self;
    fn div(self, rhs: usize) -> Self::Output {
@@ -53,6 +61,12 @@ impl From<f64> for Bitcoin {
    }
 }

+impl From<StoredF64> for Bitcoin {
+    fn from(value: StoredF64) -> Self {
+        Self(*value)
+    }
+}
+
 impl From<Bitcoin> for f64 {
    fn from(value: Bitcoin) -> Self {
        value.0
@@ -65,11 +79,40 @@ impl From<usize> for Bitcoin {
    }
 }

+impl PartialEq for Bitcoin {
+    fn eq(&self, other: &Self) -> bool {
+        match (self.0.is_nan(), other.0.is_nan()) {
+            (true, true) => true,
+            (true, false) => false,
+            (false, true) => false,
+            (false, false) => self.0 == other.0,
+        }
+    }
+}
+
 impl Eq for Bitcoin {}

 #[allow(clippy::derive_ord_xor_partial_ord)]
-impl Ord for Bitcoin {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.0.partial_cmp(&other.0).unwrap()
+impl PartialOrd for Bitcoin {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for Bitcoin {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self.0.is_nan(), other.0.is_nan()) {
+            (true, true) => Ordering::Equal,
+            (true, false) => Ordering::Less,
+            (false, true) => Ordering::Greater,
+            (false, false) => self.0.partial_cmp(&other.0).unwrap(),
+        }
+    }
+}
+
+impl CheckedSub<usize> for Bitcoin {
+    fn checked_sub(self, rhs: usize) -> Option<Self> {
+        Some(Self(self.0 - rhs as f64))
    }
 }
@@ -4,7 +4,7 @@ use bitcoin::hashes::Hash;
 use bitcoincore_rpc::{Client, RpcApi};
 use derive_deref::Deref;
 use serde::{Serialize, Serializer};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

 use super::Height;

@@ -1,8 +1,9 @@
 use byteview::ByteView;
 use derive_deref::Deref;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use crate::{Error, copy_first_8bytes};
+use crate::copy_first_8bytes;

 use super::BlockHash;

@@ -34,10 +35,9 @@ impl From<&BlockHash> for BlockHashPrefix {
    }
 }

-impl TryFrom<ByteView> for BlockHashPrefix {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
+impl From<ByteView> for BlockHashPrefix {
+    fn from(value: ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
    }
 }

@@ -1,7 +1,9 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, Div, Mul};

 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;

 use super::Dollars;

@@ -20,11 +22,17 @@ use super::Dollars;
    KnownLayout,
    Serialize,
 )]
-pub struct Cents(u64);
+pub struct Cents(i64);
+
+impl Cents {
+    pub const fn mint(value: i64) -> Self {
+        Self(value)
+    }
+}

 impl From<Dollars> for Cents {
    fn from(value: Dollars) -> Self {
-        Self((*value * 100.0).round() as u64)
+        Self((*value * 100.0).round() as i64)
    }
 }

@@ -34,15 +42,45 @@ impl From<Cents> for f64 {
    }
 }

+impl From<i64> for Cents {
+    fn from(value: i64) -> Self {
+        Self(value)
+    }
+}
+
 impl From<u64> for Cents {
    fn from(value: u64) -> Self {
-        Self(value)
+        Self(value as i64)
+    }
+}
+
+impl From<Cents> for usize {
+    fn from(value: Cents) -> Self {
+        if value.0 < 0 {
+            panic!()
+        }
+        value.0 as usize
+    }
+}
+
+impl From<usize> for Cents {
+    fn from(value: usize) -> Self {
+        Self(value as i64)
+    }
+}
+
+impl From<Cents> for i64 {
+    fn from(value: Cents) -> Self {
+        value.0
    }
 }

 impl From<Cents> for u64 {
    fn from(value: Cents) -> Self {
-        value.0
+        if value.0 < 0 {
+            panic!("Shouldn't convert neg cents to u64")
+        }
+        value.0 as u64
    }
 }

@@ -53,9 +91,61 @@ impl Add for Cents {
    }
 }

+impl Div<Cents> for Cents {
+    type Output = Self;
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
+    }
+}
+
 impl Div<usize> for Cents {
    type Output = Self;
    fn div(self, rhs: usize) -> Self::Output {
-        Self(self.0 / rhs as u64)
+        Self(self.0 / rhs as i64)
+    }
+}
+
+impl From<u128> for Cents {
+    fn from(value: u128) -> Self {
+        if value > i64::MAX as u128 {
+            panic!("u128 bigger than i64")
+        }
+        Self(value as i64)
+    }
+}
+
+impl From<Cents> for u128 {
+    fn from(value: Cents) -> Self {
+        if value.0 < 0 {
+            panic!("Shouldn't convert neg cents to u128")
+        }
+        value.0 as u128
+    }
+}
+
+impl Mul<Cents> for Cents {
+    type Output = Cents;
+    fn mul(self, rhs: Cents) -> Self::Output {
+        Self(self.0.checked_mul(rhs.0).unwrap())
+    }
+}
+
+impl Mul<i64> for Cents {
+    type Output = Cents;
+    fn mul(self, rhs: i64) -> Self::Output {
+        Self(self.0 * rhs)
+    }
+}
+
+impl Mul<usize> for Cents {
+    type Output = Cents;
+    fn mul(self, rhs: usize) -> Self::Output {
+        Self(self.0 * rhs as i64)
+    }
+}
+
+impl CheckedSub for Cents {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(Cents::from)
    }
 }
@@ -1,6 +1,6 @@
 use jiff::{Span, civil::Date as Date_, tz::TimeZone};
 use serde::{Serialize, Serializer};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

 use super::{DateIndex, Timestamp};

@@ -14,6 +14,7 @@ impl Date {
    pub const INDEX_ZERO_: Date_ = Date_::constant(2009, 1, 3);
    pub const INDEX_ONE: Self = Self(20090109);
    pub const INDEX_ONE_: Date_ = Date_::constant(2009, 1, 9);
+    pub const MIN_RATIO: Self = Self(20120101);

    pub fn new(year: u16, month: u8, day: u8) -> Self {
        Self(year as u32 * 1_00_00 + month as u32 * 1_00 + day as u32)
@@ -1,10 +1,13 @@
-use std::ops::Add;
+use std::{
+    fmt,
+    ops::{Add, Rem},
+};

 use serde::Serialize;
 // use color_eyre::eyre::eyre;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use crate::{CheckedSub, Error};
+use crate::{CheckedSub, Error, Printable};

 use super::Date;

@@ -77,3 +80,26 @@ impl CheckedSub for DateIndex {
        self.0.checked_sub(rhs.0).map(Self)
    }
 }
+
+impl Rem<usize> for DateIndex {
+    type Output = Self;
+    fn rem(self, rhs: usize) -> Self::Output {
+        Self(self.0 % rhs as u16)
+    }
+}
+
+impl fmt::Display for DateIndex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl Printable for DateIndex {
+    fn to_string() -> &'static str {
+        "dateindex"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["d", "date", "dateindex"]
+    }
+}
@@ -1,9 +1,9 @@
 use std::{fmt::Debug, ops::Add};

 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use crate::CheckedSub;
+use crate::{CheckedSub, Printable};

 use super::{Date, DateIndex, YearIndex};

@@ -83,3 +83,13 @@ impl From<YearIndex> for DecadeIndex {
        }
    }
 }
+
+impl Printable for DecadeIndex {
+    fn to_string() -> &'static str {
+        "decadeindex"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["decade", "decadeindex"]
+    }
+}
@@ -4,9 +4,9 @@ use std::{
 };

 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use crate::CheckedSub;
+use crate::{CheckedSub, Printable};

 use super::Height;

@@ -80,3 +80,13 @@ impl CheckedSub for DifficultyEpoch {
        self.0.checked_sub(rhs.0).map(Self)
    }
 }
+
+impl Printable for DifficultyEpoch {
+    fn to_string() -> &'static str {
+        "difficultyepoch"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["difficulty", "difficultyepoch"]
+    }
+}
@@ -1,27 +1,51 @@
-use std::ops::{Add, Div, Mul};
+use std::{
+    cmp::Ordering,
+    f64,
+    ops::{Add, AddAssign, Div, Mul},
+};

+use bincode::{Decode, Encode};
+use byteview::ByteView;
 use derive_deref::Deref;
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use serde::{Deserialize, Serialize};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use super::{Bitcoin, Cents, Sats};
+use crate::{CheckedSub, copy_first_8bytes};
+
+use super::{Bitcoin, Cents, Close, High, Sats, StoredF32, StoredF64};

 #[derive(
    Debug,
    Default,
    Clone,
    Copy,
-    PartialEq,
-    PartialOrd,
    Deref,
    FromBytes,
    Immutable,
    IntoBytes,
    KnownLayout,
    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
 )]
 pub struct Dollars(f64);

+impl Dollars {
+    pub const ZERO: Self = Self(0.0);
+    pub const NAN: Self = Self(f64::NAN);
+
+    pub const fn mint(dollars: f64) -> Self {
+        Self(dollars)
+    }
+}
+
+impl From<f32> for Dollars {
+    fn from(value: f32) -> Self {
+        Self(value as f64)
+    }
+}
+
 impl From<f64> for Dollars {
    fn from(value: f64) -> Self {
        Self(value)
@@ -34,12 +58,30 @@ impl From<Cents> for Dollars {
    }
 }

+impl From<Dollars> for f32 {
+    fn from(value: Dollars) -> Self {
+        value.0 as f32
+    }
+}
+
 impl From<Dollars> for f64 {
    fn from(value: Dollars) -> Self {
        value.0
    }
 }

+impl From<Close<Dollars>> for Dollars {
+    fn from(value: Close<Dollars>) -> Self {
+        Self(value.0)
+    }
+}
+
+impl From<High<Dollars>> for Dollars {
+    fn from(value: High<Dollars>) -> Self {
+        Self(value.0)
+    }
+}
+
 impl From<usize> for Dollars {
    fn from(value: usize) -> Self {
        Self(value as f64)
@@ -53,27 +95,281 @@ impl Add for Dollars {
    }
 }

+impl Div<Dollars> for Dollars {
+    type Output = StoredF64;
+    fn div(self, rhs: Dollars) -> Self::Output {
+        if self.is_nan() || rhs == Dollars::ZERO {
+            StoredF64::NAN
+        } else {
+            StoredF64::from(f64::from(self) / f64::from(rhs))
+        }
+    }
+}
+
+impl Div<Close<Dollars>> for Dollars {
+    type Output = StoredF64;
+    fn div(self, rhs: Close<Dollars>) -> Self::Output {
+        if self.is_nan() || *rhs == Dollars::ZERO {
+            StoredF64::NAN
+        } else {
+            StoredF64::from(f64::from(self) / f64::from(*rhs))
+        }
+    }
+}
+
+impl Div<Dollars> for Close<Dollars> {
+    type Output = StoredF64;
+    fn div(self, rhs: Dollars) -> Self::Output {
+        if self.is_nan() || rhs == Dollars::ZERO {
+            StoredF64::NAN
+        } else {
+            StoredF64::from(f64::from(*self) / f64::from(rhs))
+        }
+    }
+}
+
 impl Div<usize> for Dollars {
    type Output = Self;
    fn div(self, rhs: usize) -> Self::Output {
-        Self::from(Cents::from(self) / rhs)
+        if self.is_nan() || rhs == 0 {
+            Dollars::NAN
+        } else {
+            Self::from(Cents::from(self) / rhs)
+        }
+    }
+}
+
+impl Div<StoredF64> for Dollars {
+    type Output = Self;
+    fn div(self, rhs: StoredF64) -> Self::Output {
+        self / f64::from(rhs)
+    }
+}
+
+impl Div<f64> for Dollars {
+    type Output = Self;
+    fn div(self, rhs: f64) -> Self::Output {
+        if self.is_nan() || rhs == 0.0 {
+            Dollars::NAN
+        } else {
+            Dollars::from(Cents::from(Self::from(self.0 / rhs)))
+        }
+    }
+}
+
+impl Div<Bitcoin> for Dollars {
+    type Output = Self;
+    fn div(self, rhs: Bitcoin) -> Self::Output {
+        if self.is_nan() {
+            self
+        } else {
+            Self(f64::from(self) / f64::from(rhs))
+        }
+    }
+}
+
+impl Mul<Dollars> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: Dollars) -> Self::Output {
+        Self::from(Cents::from(self) * Cents::from(rhs))
+    }
+}
+
+impl Mul<Close<Dollars>> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: Close<Dollars>) -> Self::Output {
+        Self::from(Cents::from(self) * Cents::from(*rhs))
+    }
+}
+
+impl Mul<Dollars> for Close<Dollars> {
+    type Output = Dollars;
+    fn mul(self, rhs: Dollars) -> Self::Output {
+        Dollars::from(Cents::from(*self) * Cents::from(rhs))
+    }
+}
+
+impl Mul<usize> for Close<Dollars> {
+    type Output = Dollars;
+    fn mul(self, rhs: usize) -> Self::Output {
+        Dollars::from(Cents::from(*self) * rhs)
+    }
+}
+
+impl Mul<StoredF64> for Close<Dollars> {
+    type Output = Dollars;
+    fn mul(self, rhs: StoredF64) -> Self::Output {
+        *self * rhs
+    }
+}
+
+impl Mul<f64> for Dollars {
+    type Output = Dollars;
+    fn mul(self, rhs: f64) -> Self::Output {
+        if rhs.fract() != 0.0 {
+            Self::from(self.0 * rhs)
+        } else {
+            self * rhs as i64
+        }
+    }
+}
+
+impl Mul<Bitcoin> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: Bitcoin) -> Self::Output {
+        self * Sats::from(rhs)
+    }
+}
+
+impl Mul<Bitcoin> for Close<Dollars> {
+    type Output = Dollars;
+    fn mul(self, rhs: Bitcoin) -> Self::Output {
+        *self * Sats::from(rhs)
+    }
+}
+
+impl Mul<Sats> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: Sats) -> Self::Output {
+        if self.is_nan() {
+            self
+        } else {
+            Self::from(Cents::from(
+                u128::from(rhs) * u128::from(Cents::from(self)) / u128::from(Sats::ONE_BTC),
+            ))
+        }
+    }
+}
+
+impl Mul<StoredF32> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: StoredF32) -> Self::Output {
+        self * *rhs as f64
+    }
+}
+
+impl Mul<StoredF64> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: StoredF64) -> Self::Output {
+        self * *rhs
+    }
+}
+
+impl Mul<i64> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: i64) -> Self::Output {
+        Self::from(Cents::from(self) * rhs)
+    }
+}
+
+impl Mul<usize> for Dollars {
+    type Output = Self;
+    fn mul(self, rhs: usize) -> Self::Output {
+        if self.is_nan() {
+            self
+        } else {
+            Self::from(Cents::from(self) * rhs)
+        }
+    }
+}
+
+impl From<u128> for Dollars {
+    fn from(value: u128) -> Self {
+        Self::from(Cents::from(value))
+    }
+}
+
+impl From<StoredF64> for Dollars {
+    fn from(value: StoredF64) -> Self {
+        Self(*value)
+    }
+}
+
+impl From<Close<Dollars>> for u128 {
+    fn from(value: Close<Dollars>) -> Self {
+        u128::from(*value)
+    }
+}
+
+impl From<Dollars> for u128 {
+    fn from(value: Dollars) -> Self {
+        u128::from(Cents::from(value))
+    }
+}
+
+impl AddAssign for Dollars {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = Dollars::from(Cents::from(*self) + Cents::from(rhs));
+    }
+}
+
+impl CheckedSub for Dollars {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        if self.is_nan() {
+            Some(self)
+        } else {
+            Cents::from(self)
+                .checked_sub(Cents::from(rhs))
+                .map(Dollars::from)
+        }
+    }
+}
+
+impl CheckedSub<usize> for Dollars {
+    fn checked_sub(self, rhs: usize) -> Option<Self> {
+        Some(Dollars::from(
+            Cents::from(self).checked_sub(Cents::from(rhs)).unwrap(),
+        ))
+    }
+}
+
+impl PartialEq for Dollars {
+    fn eq(&self, other: &Self) -> bool {
+        match (self.0.is_nan(), other.0.is_nan()) {
+            (true, true) => true,
+            (true, false) => false,
+            (false, true) => false,
+            (false, false) => self.0 == other.0,
+        }
    }
 }

 impl Eq for Dollars {}

 #[allow(clippy::derive_ord_xor_partial_ord)]
-impl Ord for Dollars {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.0.partial_cmp(&other.0).unwrap()
+impl PartialOrd for Dollars {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
    }
 }

-impl Mul<Bitcoin> for Dollars {
-    type Output = Dollars;
-    fn mul(self, rhs: Bitcoin) -> Self::Output {
-        Self::from(Cents::from(
-            u64::from(Sats::from(rhs)) * u64::from(Cents::from(self)) / u64::from(Sats::ONE_BTC),
-        ))
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for Dollars {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self.0.is_nan(), other.0.is_nan()) {
+            (true, true) => Ordering::Equal,
+            (true, false) => Ordering::Less,
+            (false, true) => Ordering::Greater,
+            (false, false) => self.0.partial_cmp(&other.0).unwrap(),
+        }
+    }
+}
+
+impl From<ByteView> for Dollars {
+    fn from(value: ByteView) -> Self {
+        let bytes = copy_first_8bytes(&value).unwrap();
+        Self::from(f64::from_be_bytes(bytes))
+    }
+}
+
+impl From<Dollars> for ByteView {
+    fn from(value: Dollars) -> Self {
+        Self::from(&value)
+    }
+}
+
+impl From<&Dollars> for ByteView {
+    fn from(value: &Dollars) -> Self {
+        Self::new(&value.to_be_bytes())
    }
 }
@@ -0,0 +1,61 @@
+use std::ops::Add;
+
+use derive_deref::{Deref, DerefMut};
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{CheckedSub, Printable, TypeIndex};
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct EmptyOutputIndex(TypeIndex);
+impl From<TypeIndex> for EmptyOutputIndex {
+    fn from(value: TypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<EmptyOutputIndex> for usize {
+    fn from(value: EmptyOutputIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for EmptyOutputIndex {
+    fn from(value: usize) -> Self {
+        Self(TypeIndex::from(value))
+    }
+}
+impl Add<usize> for EmptyOutputIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<EmptyOutputIndex> for EmptyOutputIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(Self)
+    }
+}
+impl Printable for EmptyOutputIndex {
+    fn to_string() -> &'static str {
+        "emptyoutputindex"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["emptyout", "emptyoutputindex"]
+    }
+}
@@ -1,22 +1,14 @@
-use std::ops::{Add, Div};
+use std::{
+    cmp::Ordering,
+    ops::{Add, Div},
+};

 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

 use super::{Sats, StoredUsize};

-#[derive(
-    Debug,
-    Clone,
-    Copy,
-    Serialize,
-    PartialEq,
-    PartialOrd,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-)]
+#[derive(Debug, Clone, Copy, Serialize, FromBytes, Immutable, IntoBytes, KnownLayout)]
 pub struct Feerate(f32);

 impl From<(Sats, StoredUsize)> for Feerate {
@@ -56,11 +48,34 @@ impl From<usize> for Feerate {
    }
 }

+impl PartialEq for Feerate {
+    fn eq(&self, other: &Self) -> bool {
+        match (self.0.is_nan(), other.0.is_nan()) {
+            (true, true) => true,
+            (true, false) => false,
+            (false, true) => false,
+            (false, false) => self.0 == other.0,
+        }
+    }
+}
+
 impl Eq for Feerate {}

 #[allow(clippy::derive_ord_xor_partial_ord)]
-impl Ord for Feerate {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.0.partial_cmp(&other.0).unwrap()
+impl PartialOrd for Feerate {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for Feerate {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self.0.is_nan(), other.0.is_nan()) {
+            (true, true) => Ordering::Equal,
+            (true, false) => Ordering::Less,
+            (false, true) => Ordering::Greater,
+            (false, false) => self.0.partial_cmp(&other.0).unwrap(),
+        }
    }
 }
@@ -4,9 +4,9 @@ use std::{
 };

 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use crate::CheckedSub;
+use crate::{CheckedSub, Printable};

 use super::Height;

@@ -28,6 +28,12 @@ use super::Height;
 )]
 pub struct HalvingEpoch(u8);

+impl HalvingEpoch {
+    pub fn new(value: u8) -> Self {
+        Self(value)
+    }
+}
+
 impl From<u8> for HalvingEpoch {
    fn from(value: u8) -> Self {
        Self(value)
@@ -80,3 +86,13 @@ impl Div<usize> for HalvingEpoch {
        Self::from(self.0 as usize / rhs)
    }
 }
+
+impl Printable for HalvingEpoch {
+    fn to_string() -> &'static str {
+        "halvingepoch"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["halving", "halvingepoch"]
+    }
+}
@@ -4,10 +4,14 @@ use std::{
 };

 use bitcoincore_rpc::{Client, RpcApi};
+use byteview::ByteView;
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use crate::CheckedSub;
+use crate::{CheckedSub, Printable};
+
+use super::StoredUsize;

 #[derive(
    Debug,
@@ -146,11 +150,17 @@ impl From<u64> for Height {
    }
 }

+impl From<StoredUsize> for Height {
+    fn from(value: StoredUsize) -> Self {
+        Self(*value as u32)
+    }
+}
 impl From<usize> for Height {
    fn from(value: usize) -> Self {
        Self(value as u32)
    }
 }
+
 impl From<Height> for usize {
    fn from(value: Height) -> Self {
        value.0 as usize
@@ -188,10 +198,9 @@ impl TryFrom<&std::path::Path> for Height {
    }
 }

-impl TryFrom<byteview::ByteView> for Height {
-    type Error = crate::Error;
-    fn try_from(value: byteview::ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
+impl From<ByteView> for Height {
+    fn from(value: byteview::ByteView) -> Self {
+        Self::read_from_bytes(&value).unwrap()
    }
 }

@@ -200,3 +209,13 @@ impl From<Height> for byteview::ByteView {
        Self::new(value.as_bytes())
    }
 }
+
+impl Printable for Height {
+    fn to_string() -> &'static str {
+        "height"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["h", "height"]
+    }
+}
@@ -2,9 +2,9 @@ use std::ops::{Add, AddAssign};

 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};

-use crate::CheckedSub;
+use crate::{CheckedSub, Printable};

 use super::Vin;

@@ -96,3 +96,13 @@ impl From<InputIndex> for usize {
        value.0 as usize
    }
 }
+
+impl Printable for InputIndex {
+    fn to_string() -> &'static str {
+        "inputindex"
+    }
+
+    fn to_possible_strings() -> &'static [&'static str] {
+        &["in", "inputindex"]
+    }
+}
@@ -1,8 +1,5 @@
 mod addressbytes;
 mod addressbyteshash;
-// mod addressindex;
-// mod addressindexoutputindex;
-// mod addresstype;
 mod bitcoin;
 mod blockhash;
 mod blockhashprefix;
@@ -12,18 +9,29 @@ mod dateindex;
 mod decadeindex;
 mod difficultyepoch;
 mod dollars;
+mod emptyoutputindex;
 mod feerate;
 mod halvingepoch;
 mod height;
 mod inputindex;
 mod monthindex;
 mod ohlc;
+mod opreturnindex;
 mod outputindex;
 mod outputtype;
-mod outputtypeindex;
+mod p2aaddressindex;
+mod p2msoutputindex;
+mod p2pk33addressindex;
+mod p2pk65addressindex;
+mod p2pkhaddressindex;
+mod p2shaddressindex;
+mod p2traddressindex;
+mod p2wpkhaddressindex;
+mod p2wshaddressindex;
 mod quarterindex;
 mod rawlocktime;
 mod sats;
+mod stored_f32;
 mod stored_f64;
 mod stored_u32;
 mod stored_u64;
@@ -34,7 +42,10 @@ mod txid;
 mod txidprefix;
 mod txindex;
 mod txversion;
+mod typeindex;
 mod unit;
+mod unknownoutputindex;
+mod version;
 mod vin;
 mod vout;
 mod weekindex;
@@ -43,9 +54,6 @@ mod yearindex;

 pub use addressbytes::*;
 pub use addressbyteshash::*;
-// pub use addressindex::*;
-// pub use addressindexoutputindex::*;
-// pub use addresstype::*;
 pub use bitcoin::*;
 pub use blockhash::*;
 pub use blockhashprefix::*;
@@ -55,18 +63,29 @@ pub use dateindex::*;
 pub use decadeindex::*;
 pub use difficultyepoch::*;
 pub use dollars::*;
+pub use emptyoutputindex::*;
 pub use feerate::*;
 pub use halvingepoch::*;
 pub use height::*;
 pub use inputindex::*;
 pub use monthindex::*;
 pub use ohlc::*;
+pub use opreturnindex::*;
 pub use outputindex::*;
 pub use outputtype::*;
-pub use outputtypeindex::*;
+pub use p2aaddressindex::*;
+pub use p2msoutputindex::*;
+pub use p2pk33addressindex::*;
+pub use p2pk65addressindex::*;
+pub use p2pkhaddressindex::*;
+pub use p2shaddressindex::*;
+pub use p2traddressindex::*;
+pub use p2wpkhaddressindex::*;
+pub use p2wshaddressindex::*;
 pub use quarterindex::*;
 pub use rawlocktime::*;
 pub use sats::*;
+pub use stored_f32::*;
 pub use stored_f64::*;
 pub use stored_u8::*;
 pub use stored_u32::*;
@@ -77,9 +96,14 @@ pub use txid::*;
 pub use txidprefix::*;
 pub use txindex::*;
 pub use txversion::*;
+pub use typeindex::*;
 pub use unit::*;
+pub use unknownoutputindex::*;
+pub use version::*;
 pub use vin::*;
 pub use vout::*;
 pub use weekindex::*;
 pub use weight::*;
 pub use yearindex::*;
+
+pub use rlimit;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
nym21	e4c9f23476	release: v0.0.69	2025-06-24 13:23:14 +02:00
nym21	44e5415d43	vec: undo storing file in struct, can overwhelm system	2025-06-24 13:20:44 +02:00
nym21	1c653693ed	release: v0.0.68	2025-06-24 12:19:07 +02:00
nym21	39c470ad7a	core: increase max open files limit	2025-06-24 12:18:49 +02:00
nym21	1103e538a5	release: v0.0.67	2025-06-24 11:57:25 +02:00
nym21	c0cd4cba6f	global: snapshot	2025-06-24 11:56:54 +02:00
nym21	b91120e8d4	readme: update	2025-06-24 08:42:40 +00:00
nym21	005774a4c2	mcp: update readme	2025-06-24 08:41:08 +00:00
nym21	16bbfebfba	changelog: update titles	2025-06-24 08:26:01 +00:00
nym21	15505cd82d	web: fix index type imports	2025-06-24 10:23:16 +02:00
nym21	016d80e002	server: use etag for vecs instead of date modified	2025-06-24 10:11:03 +02:00
nym21	0f3c267a48	global: rename some indexes	2025-06-23 22:00:09 +02:00
nym21	589bb02411	vec: single file with header	2025-06-23 20:48:00 +02:00
nym21	c0f4ece17b	mcp: part 2	2025-06-21 20:34:14 +02:00
nym21	c3ae3cb768	server: mcp + global: refactor	2025-06-21 12:43:14 +02:00
nym21	c9e0f9d985	query: remove dup 'h' short index	2025-06-19 14:16:24 +02:00
nym21	e3431c2fa3	release: v0.0.66	2025-06-19 12:32:04 +02:00
nym21	5979b9771e	global: cointime part 1	2025-06-19 12:29:34 +02:00
nym21	aa61832fb2	web: fix options cmumulative possible vecids type	2025-06-18 10:14:09 +02:00
nym21	2ac6e982b1	computer: cumulative destroyed coinblocks and cointime	2025-06-18 10:13:33 +02:00
nym21	3204ddcf07	pr: merge #18 from StevenBlack/typos Minor refinements to the brk_cli readme	2025-06-17 23:06:32 +02:00
nym21	c87b1c133c	release: v0.0.65	2025-06-17 22:30:32 +02:00
nym21	9b275ecdae	web: fix hang when candles fetched are slightly diff than before	2025-06-17 22:30:11 +02:00
Steven Black	d6fd7de361	Minor refinements to the brk_cli readme * Fix typos * Rephrasing some descriptions * Links to run command parameters now link to the code as it is in blob `49d66a133e` specifically. * Lightly introduce some nice features of Github flavored markdown (IMPORTANT and TIP) to assess how this nuance is received by maintainers.	2025-06-17 14:07:03 -04:00
nym21	49d66a133e	release: v0.0.64	2025-06-17 18:49:17 +02:00
nym21	c559f26d0e	global: add a bunch of realized datasets + charts	2025-06-17 18:47:04 +02:00
nym21	bbe9f1bad2	global: 4y zscore + 200d sma + mayer's multiple	2025-06-17 10:01:49 +02:00
nym21	7e1fb6472d	release: v0.0.63	2025-06-16 23:46:57 +02:00
nym21	0ff8d20573	web: fix the fix for the stutter + pwa assets	2025-06-16 23:46:39 +02:00
nym21	9c1f9448dc	release: v0.0.62	2025-06-16 18:56:59 +02:00
nym21	43a6081dd6	web: fix stutter on update and save default chart settings to url params	2025-06-16 18:56:38 +02:00
nym21	985e961876	web: fix error in lockdown safari + charts: update instead of setData when possible	2025-06-16 18:20:56 +02:00
nym21	098f6de047	release: v0.0.61	2025-06-15 17:30:49 +02:00
nym21	1b0f90fd68	release: v0.0.60	2025-06-15 17:27:41 +02:00
nym21	12252f407b	computer: fix open of ohlc if fetched from different API than prev ohlc	2025-06-15 17:27:16 +02:00
nym21	3b6e3f47ab	release: v0.0.59	2025-06-15 12:40:46 +02:00
nym21	6a9ac9b025	brk: fix bundler use + bundler: remove minify html crate	2025-06-15 12:39:50 +02:00
nym21	ae6aa4088b	release: v0.0.58	2025-06-15 01:50:22 +02:00
nym21	c08f431180	bundler: deploy brk_rolldown + fix edge case	2025-06-15 01:50:01 +02:00
nym21	123c1f56e9	release: v0.0.57	2025-06-14 22:47:57 +02:00
nym21	35ac65a864	server: update cache control for bundled websites	2025-06-14 22:47:26 +02:00
nym21	e9f362cc87	bundler: init working version	2025-06-14 20:17:49 +02:00
nym21	65685c23e1	release: v0.0.56	2025-06-13 18:03:28 +02:00
nym21	2f74748cea	computer: stateful: reset when reorg detected	2025-06-13 18:03:09 +02:00
nym21	f477bd66f3	release: v0.0.55	2025-06-13 10:23:38 +02:00
nym21	d7d77ae8f0	global: multiple fixes	2025-06-13 10:22:03 +02:00
nym21	31110a740d	release: v0.0.54	2025-06-12 22:18:36 +02:00
nym21	b64d8b1d7f	release: v0.0.53	2025-06-12 22:16:33 +02:00
nym21	c46006aacc	web: filter possible index choices in charts	2025-06-12 22:09:33 +02:00
nym21	92f81b1493	web: fix css	2025-06-12 20:23:23 +02:00
nym21	70213cfc8f	websites: default: add auto price series type	2025-06-12 18:41:56 +02:00
nym21	8a82bf5c50	websites: default: add live price	2025-06-12 18:10:24 +02:00
nym21	37405384a2	vec: fixed compressed, still slow par read, cli: made raw the default	2025-06-12 16:31:54 +02:00
nym21	54ea6cc53b	indexer: only raw format + global: fixes	2025-06-12 12:33:43 +02:00
nym21	339c00d815	release: v0.0.52	2025-06-11 21:19:41 +02:00
nym21	ea6b4dcde2	websites: default: remove scrollToSelected	2025-06-11 21:19:22 +02:00
nym21	2b84623d1e	release: v0.0.51	2025-06-11 21:09:07 +02:00
nym21	c8b3afa56b	websites: default: fix sw adn co	2025-06-11 21:08:42 +02:00
nym21	1348f3c24c	release: v0.0.50	2025-06-11 18:11:22 +02:00
nym21	62208ce3e1	websites: default: fix minBarSpacing	2025-06-11 18:11:11 +02:00
nym21	813b2481de	release: v0.0.49	2025-06-11 17:51:31 +02:00
nym21	27b924ba61	cargo: set full version of crates	2025-06-11 17:51:11 +02:00
nym21	b40170b8ce	websites: default: snapshot	2025-06-11 17:45:17 +02:00
nym21	8bfa9d2734	websites: default: snapshot	2025-06-11 11:25:25 +02:00
nym21	c7cf76d4a8	websites: default: snapshot	2025-06-10 18:54:18 +02:00
nym21	dfd2969b3e	websites: default: snapshot	2025-06-09 17:58:26 +02:00
nym21	0e1866fe1d	release: v0.0.48	2025-06-09 13:53:33 +02:00
nym21	b9ae46b913	readme: update	2025-06-09 13:53:09 +02:00
nym21	06e7284055	websites: default: snapshot	2025-06-09 13:05:03 +02:00
nym21	93289e8fca	release: v0.0.47	2025-06-08 20:35:36 +02:00
nym21	130d5057d4	server: readme: add index-t-value documentation	2025-06-08 20:35:26 +02:00
nym21	be492d5084	server: add support for /api/X-to-Y + fix query cli + add meta api endpoints	2025-06-08 20:30:53 +02:00
nym21	e0bf1d736f	query: add count param	2025-06-08 18:26:59 +02:00
nym21	5a6b71cbeb	server: add ddos protection	2025-06-08 17:06:36 +02:00
nym21	e6934cd5e2	release: v0.0.46	2025-06-08 16:06:27 +02:00
nym21	b5aada0792	websites: mv sw to root	2025-06-08 16:05:21 +02:00
nym21	165ea83ac3	websites: update service worker	2025-06-08 13:03:37 +02:00
nym21	440a82dee4	release: v0.0.45	2025-06-08 09:11:31 +02:00
nym21	9c2d3e5e26	server: fix existing folder endpoints	2025-06-08 09:10:55 +02:00
nym21	6fb6abcbe5	release: v0.0.44	2025-06-07 18:53:51 +02:00
nym21	dc449dafd1	websites: default: up deps + fix css	2025-06-07 18:53:34 +02:00
nym21	ecdaeebbfb	release: v0.0.43	2025-06-07 13:48:25 +02:00
nym21	fa958b59bd	fetcher: support new api	2025-06-07 13:48:07 +02:00
nym21	fb3d8521cd	computer: coinblocks fix overflow	2025-06-07 13:29:08 +02:00
nym21	608c401cf3	release: v0.0.42	2025-06-07 10:40:32 +02:00
nym21	1c3da90a24	release: v0.0.41	2025-06-07 10:31:36 +02:00
nym21	34567f3375	changelog: reset last	2025-06-07 10:31:07 +02:00
nym21	51bcbeb48f	global: multiple fixes	2025-06-07 09:30:42 +02:00
nym21	cc0f9c42df	global: snapshot	2025-06-06 16:08:20 +02:00
nym21	a11bf5523b	global: wip	2025-06-06 12:23:45 +02:00
nym21	1921c3d901	global: wip	2025-06-06 10:46:38 +02:00
nym21	d568469e8b	global: works but data is wrong	2025-06-04 17:01:16 +02:00
nym21	20d5c7e8d5	global: wip + fixed eager mode	2025-06-03 17:49:20 +02:00
nym21	9f289ed9de	global: wip	2025-06-03 10:11:51 +02:00
nym21	93ee5e480b	global: wip	2025-06-02 18:22:42 +02:00
nym21	98a312701f	computer: more frequent flushes	2025-06-01 16:11:13 +02:00
nym21	cbcf603b63	global: wip	2025-06-01 14:37:19 +02:00
nym21	f976f672cf	global: wip	2025-05-31 20:45:59 +02:00
nym21	cfc3081e8a	global: snapshot	2025-05-29 10:39:58 +02:00
nym21	99818924ee	global: snapshot	2025-05-28 16:53:18 +02:00
nym21	9bbf3a027f	global: snapshot	2025-05-28 15:42:55 +02:00
nym21	93e01902e3	global: snapshot	2025-05-27 15:19:53 +02:00
nym21	34919aba05	global: versions	2025-05-26 11:34:37 +02:00
nym21	a8ee4cf57f	release: v0.0.40	2025-05-25 13:38:48 +02:00
nym21	b39548b4c6	core: fix eq and cmp of float structs	2025-05-25 12:35:52 +02:00
nym21	4217c22ff6	global: utxos part 8	2025-05-25 00:27:18 +02:00
nym21	4ab10670c9	global: utxos part 7	2025-05-24 12:52:15 +02:00
nym21	2883f88de6	global: utxos part 6	2025-05-23 17:52:01 +02:00
nym21	e002a61a19	global: utxos part 5	2025-05-22 19:04:55 +02:00
nym21	5893376279	global: utxos part 4	2025-05-19 17:53:09 +02:00
nym21	411c5e4c4d	global: snapshot	2025-05-18 17:28:09 +02:00
nym21	c2a77072d2	global: utxos part 3	2025-05-18 11:52:14 +02:00
nym21	c8a25934a6	global: utxos part 2	2025-05-17 19:51:52 +02:00
nym21	7b38355cd4	release: v0.0.39	2025-05-16 23:37:51 +02:00
nym21	ddc54e0b98	release: v0.0.38	2025-05-16 23:34:32 +02:00
nym21	8a7003782b	global: utxos dataset part 1	2025-05-16 23:33:19 +02:00
nym21	8e6464dacb	release: v0.0.37	2025-05-14 11:28:38 +02:00
nym21	92b1dc0afb	global: dca classes	2025-05-14 11:28:18 +02:00
nym21	7562f51e07	release: v0.0.36	2025-05-13 13:01:32 +02:00
nym21	09bba99e68	kibo: add priceline	2025-05-13 13:01:11 +02:00
nym21	9d674cd49b	global: snapshot	2025-05-13 11:46:03 +02:00
nym21	88a0c9ea03	global: returns (lump sum vs dca)	2025-05-13 01:27:21 +02:00
nym21	5014e0ce3e	release: v0.0.35	2025-05-12 12:56:08 +02:00
nym21	b7a1ee9ebc	global: averages + ratio datasets	2025-05-12 12:55:40 +02:00
nym21	292ceddd66	comp + kibo: add market smas	2025-05-10 13:17:51 +02:00
nym21	4b52b80000	release: v0.0.34	2025-05-09 21:35:07 +02:00
nym21	9f20664c6e	global: add some market charts	2025-05-09 16:04:54 +02:00
nym21	851a6aac0e	release: v0.0.33	2025-05-08 12:53:19 +02:00
nym21	1f1e73c47a	vec: computed: fix eager path + delete path if lazy	2025-05-08 12:31:31 +02:00
nym21	112f61ca18	release: v0.0.32	2025-05-08 11:17:35 +02:00
nym21	96eeacbe2b	lazy: done	2025-05-08 11:15:47 +02:00
nym21	3f62da879c	comp + lazy: part 6	2025-05-06 12:23:37 +02:00
nym21	aa30feb875	comp + vec: snapshot before bug hunting	2025-05-06 00:44:39 +02:00
nym21	9ba3c2b7c5	global: big vec refactor + lazy	2025-05-05 12:47:52 +02:00
nym21	320c708e10	computer: lazy part 4	2025-05-03 17:28:48 +02:00
nym21	efa7294f59	computer: lazy part 3	2025-05-03 11:44:33 +02:00
nym21	ae0e092935	computer: lazy part 2	2025-05-01 20:52:39 +02:00
nym21	c77aecbfce	computer: lazy part 1	2025-05-01 17:25:59 +02:00
nym21	700352ec45	vec: caching only in iter	2025-04-30 18:29:18 +02:00