release: v0.0.19

.github/workflows/release.yml

@@ -0,0 +1,291 @@
+# This file was autogenerated by dist: https://opensource.axo.dev/cargo-dist/
+#
+# Copyright 2022-2024, axodotdev
+# SPDX-License-Identifier: MIT or Apache-2.0
+#
+# CI that:
+#
+# * checks for a Git Tag that looks like a release
+# * builds artifacts with dist (archives, installers, hashes)
+# * uploads those artifacts to temporary workflow zip
+# * on success, uploads the artifacts to a GitHub Release
+#
+# Note that the GitHub Release will be created with a generated
+# title/body based on your changelogs.
+
+name: Release
+permissions:
+  "contents": "write"
+
+# This task will run whenever you push a git tag that looks like a version
+# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
+# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
+# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
+# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
+#
+# If PACKAGE_NAME is specified, then the announcement will be for that
+# package (erroring out if it doesn't have the given version or isn't dist-able).
+#
+# If PACKAGE_NAME isn't specified, then the announcement will be for all
+# (dist-able) packages in the workspace with that version (this mode is
+# intended for workspaces with only one dist-able package, or with all dist-able
+# packages versioned/released in lockstep).
+#
+# If you push multiple tags at once, separate instances of this workflow will
+# spin up, creating an independent announcement for each one. However, GitHub
+# will hard limit this to 3 tags per commit, as it will assume more tags is a
+# mistake.
+#
+# If there's a prerelease-style suffix to the version, then the release(s)
+# will be marked as a prerelease.
+on:
+  pull_request:
+  push:
+    tags:
+      - '**[0-9]+.[0-9]+.[0-9]+*'
+
+jobs:
+  # Run 'dist plan' (or host) to determine what tasks we need to do
+  plan:
+    runs-on: "ubuntu-20.04"
+    outputs:
+      val: ${{ steps.plan.outputs.manifest }}
+      tag: ${{ !github.event.pull_request && github.ref_name || '' }}
+      tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
+      publishing: ${{ !github.event.pull_request }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install dist
+        # we specify bash to get pipefail; it guards against the `curl` command
+        # failing. otherwise `sh` won't catch that `curl` returned non-0
+        shell: bash
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.28.0/cargo-dist-installer.sh | sh"
+      - name: Cache dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/dist
+      # sure would be cool if github gave us proper conditionals...
+      # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
+      # functionality based on whether this is a pull_request, and whether it's from a fork.
+      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
+      # but also really annoying to build CI around when it needs secrets to work right.)
+      - id: plan
+        run: |
+          dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json
+          echo "dist ran successfully"
+          cat plan-dist-manifest.json
+          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-plan-dist-manifest
+          path: plan-dist-manifest.json
+
+  # Build and packages all the platform-specific things
+  build-local-artifacts:
+    name: build-local-artifacts (${{ join(matrix.targets, ', ') }})
+    # Let the initial task tell us to not run (currently very blunt)
+    needs:
+      - plan
+    if: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix.include != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }}
+    strategy:
+      fail-fast: false
+      # Target platforms/runners are computed by dist in create-release.
+      # Each member of the matrix has the following arguments:
+      #
+      # - runner: the github runner
+      # - dist-args: cli flags to pass to dist
+      # - install-dist: expression to run to install dist on the runner
+      #
+      # Typically there will be:
+      # - 1 "global" task that builds universal installers
+      # - N "local" tasks that build each platform's binaries and platform-specific installers
+      matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }}
+    runs-on: ${{ matrix.runner }}
+    container: ${{ matrix.container && matrix.container.image || null }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
+    steps:
+      - name: enable windows longpaths
+        run: |
+          git config --global core.longpaths true
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install Rust non-interactively if not already installed
+        if: ${{ matrix.container }}
+        run: |
+          if ! command -v cargo > /dev/null 2>&1; then
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+            echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+          fi
+      - name: Install dist
+        run: ${{ matrix.install_dist.run }}
+      # Get the dist-manifest
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - name: Install dependencies
+        run: |
+          ${{ matrix.packages_install }}
+      - name: Build artifacts
+        run: |
+          # Actually do builds and make zips and whatnot
+          dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json
+          echo "dist ran successfully"
+      - id: cargo-dist
+        name: Post-build
+        # We force bash here just because github makes it really hard to get values up
+        # to "real" actions without writing to env-vars, and writing to env-vars has
+        # inconsistent syntax between shell and powershell.
+        shell: bash
+        run: |
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          dist print-upload-files-from-manifest --manifest dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-local-${{ join(matrix.targets, '_') }}
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+
+  # Build and package all the platform-agnostic(ish) things
+  build-global-artifacts:
+    needs:
+      - plan
+      - build-local-artifacts
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/dist
+      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: cargo-dist
+        shell: bash
+        run: |
+          dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "dist ran successfully"
+
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-global
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+  # Determines if we should publish/announce
+  host:
+    needs:
+      - plan
+      - build-local-artifacts
+      - build-global-artifacts
+    # Only run if we're "publishing", and only if local and global didn't fail (skipped is fine)
+    if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    runs-on: "ubuntu-20.04"
+    outputs:
+      val: ${{ steps.host.outputs.manifest }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cached dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/dist
+      # Fetch artifacts from scratch-storage
+      - name: Fetch artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: host
+        shell: bash
+        run: |
+          dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          echo "artifacts uploaded and released successfully"
+          cat dist-manifest.json
+          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          # Overwrite the previous copy
+          name: artifacts-dist-manifest
+          path: dist-manifest.json
+      # Create a GitHub Release while uploading all files to it
+      - name: "Download GitHub Artifacts"
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: artifacts
+          merge-multiple: true
+      - name: Cleanup
+        run: |
+          # Remove the granular manifests
+          rm -f artifacts/*-dist-manifest.json
+      - name: Create GitHub Release
+        env:
+          PRERELEASE_FLAG: "${{ fromJson(steps.host.outputs.manifest).announcement_is_prerelease && '--prerelease' || '' }}"
+          ANNOUNCEMENT_TITLE: "${{ fromJson(steps.host.outputs.manifest).announcement_title }}"
+          ANNOUNCEMENT_BODY: "${{ fromJson(steps.host.outputs.manifest).announcement_github_body }}"
+          RELEASE_COMMIT: "${{ github.sha }}"
+        run: |
+          # Write and read notes from a file to avoid quoting breaking things
+          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
+
+          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
+
+  announce:
+    needs:
+      - plan
+      - host
+    # use "always() && ..." to allow us to wait for all publish jobs while
+    # still allowing individual publish jobs to skip themselves (for prereleases).
+    # "host" however must run to completion, no skipping allowed!
+    if: ${{ always() && needs.host.result == 'success' }}
+    runs-on: "ubuntu-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive

CHANGELOG.md

@@ -36,7 +36,7 @@ Added git tags for each version though Markdown won't display formatted on Githu
 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.
 
-# [v0.5.0](https://github.com/kibo-money/kibo/tree/eea56d394bf92c62c81da8b78b8c47ea730683f5) | [873199](https://mempool.space/block/0000000000000000000270925aa6a565be92e13164565a3f7994ca1966e48050) - 2024/12/04
+# [kibo-v0.5.0](https://github.com/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)
 
@@ -103,7 +103,7 @@ Since it's not used anymore it will moved out of the repository relatively soon.
 
 - Moved back to this repo
 
-# [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/kibo-money/kibo/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)
 
@@ -140,7 +140,7 @@ Since it's not used anymore it will moved out of the repository relatively soon.
 - Added serving of the website
 - Improved `Cache-Control` behavior
 
-# [v0.3.0](https://github.com/kibo-money/kibo/tree/b68b016091c45b071218fba01bac5b76e8eaf18c) | [853930](https://mempool.space/block/00000000000000000002eb5e9a7950ca2d5d98bd1ed28fc9098aa630d417985d) - 2024/07/26
+# [kibo-v0.3.0](https://github.com/kibo-money/kibo/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)
 
@@ -219,7 +219,7 @@ 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`
 
-# [v0.2.0](https://github.com/kibo-money/kibo/tree/248187889283597c5dbb806292297453c25e97b8) | [851286](https://mempool.space/block/0000000000000000000281ca7f1bf8c50702bfca168c7af1bdc67c977c1ac8ed) - 2024/07/08
+# [kibo-v0.2.0](https://github.com/kibo-money/kibo/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)
 
@@ -255,7 +255,7 @@ 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
 
-# [v0.1.1](https://github.com/kibo-money/kibo/tree/e55b5195a9de9aea306903c94ed63cb1720fda5f) | [849240](https://mempool.space/block/000000000000000000002b8653988655071c07bb5f7181c038f9326bc86db741) - 2024/06/24
+# [kibo-v0.1.1](https://github.com/kibo-money/kibo/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)
 
@@ -305,10 +305,10 @@ Since it's not used anymore it will moved out of the repository relatively soon.
 
 - Deleted old price datasets and their backups
 
-# [v0.1.0](https://github.com/kibo-money/kibo/tree/a1a576d088c8f83ed32d48753a7611f70a964574) | [848642](https://mempool.space/block/000000000000000000020be5761d70751252219a9557f55e91ecdfb86c4e026a) - 2024/06/19
+# [kibo-v0.1.0](https://github.com/kibo-money/kibo/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)
 
-# v0.0.1 | [835444](https://mempool.space/block/000000000000000000009f93907a0dd83c080d5585cc7ec82c076d45f6d7c872) - 2024/03/20
+# kibo-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)

Cargo.lock

@@ -368,7 +368,7 @@ dependencies = [
 
 [[package]]
 name = "brk"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "brk_cli",
  "brk_computer",
@@ -385,7 +385,7 @@ dependencies = [
 
 [[package]]
 name = "brk_cli"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "brk_computer",
  "brk_core",
@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "brk_computer"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "brk_core",
  "brk_exit",
@@ -421,7 +421,7 @@ dependencies = [
 
 [[package]]
 name = "brk_core"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "bitcoin",
  "bitcoincore-rpc",
@@ -438,7 +438,7 @@ dependencies = [
 
 [[package]]
 name = "brk_exit"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "brk_logger",
  "ctrlc",
@@ -447,7 +447,7 @@ dependencies = [
 
 [[package]]
 name = "brk_fetcher"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "brk_core",
  "brk_logger",
@@ -460,7 +460,7 @@ dependencies = [
 
 [[package]]
 name = "brk_indexer"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "bitcoin",
  "bitcoincore-rpc",
@@ -479,7 +479,7 @@ dependencies = [
 
 [[package]]
 name = "brk_logger"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "color-eyre",
  "env_logger",
@@ -489,7 +489,7 @@ dependencies = [
 
 [[package]]
 name = "brk_parser"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "bitcoin",
  "bitcoincore-rpc",
@@ -504,7 +504,7 @@ dependencies = [
 
 [[package]]
 name = "brk_query"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "brk_computer",
  "brk_indexer",
@@ -520,7 +520,7 @@ dependencies = [
 
 [[package]]
 name = "brk_server"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "axum",
  "brk_computer",
@@ -541,13 +541,12 @@ dependencies = [
  "tokio",
  "tower-http",
  "tracing",
- "tracing-subscriber",
  "zip",
 ]
 
 [[package]]
 name = "brk_vec"
-version = "0.0.16"
+version = "0.0.19"
 dependencies = [
  "memmap2",
  "rayon",
@@ -972,9 +971,9 @@ checksum = "da692b8d1080ea3045efaab14434d40468c3d8657e42abddfffca87b428f4c1b"
 
 [[package]]
 name = "deranged"
-version = "0.4.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28cfac68e08048ae1883171632c2aef3ebc555621ae56fbccce1cbf22dd7f058"
+checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
  "powerfmt",
  "serde",
@@ -1413,9 +1412,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058"
+checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
 dependencies = [
  "equivalent",
  "hashbrown 0.15.2",
@@ -1713,16 +1712,6 @@ version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51"
 
-[[package]]
-name = "nu-ansi-term"
-version = "0.46.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
-dependencies = [
- "overload",
- "winapi",
-]
-
 [[package]]
 name = "num-bigint"
 version = "0.4.6"
@@ -1778,12 +1767,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
 [[package]]
 name = "owo-colors"
 version = "3.5.0"
@@ -2213,7 +2196,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
 dependencies = [
  "fixedbitset",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
 ]
 
 [[package]]
@@ -2420,9 +2403,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.10"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
+checksum = "d2f103c6d277498fbceb16e84d317e2a400f160f46904d5f5410848c829511a3"
 dependencies = [
  "bitflags",
 ]
@@ -2675,7 +2658,7 @@ dependencies = [
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "serde",
  "serde_derive",
  "serde_json",
@@ -2750,9 +2733,9 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "smallvec"
-version = "1.14.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
 
 [[package]]
 name = "smawk"
@@ -2932,9 +2915,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.44.1"
+version = "1.44.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f382da615b842244d4b8738c82ed1275e6c5dd90c459a30941cd07080b06c91a"
+checksum = "e6b88822cbe49de4185e3a4cbf8321dd487cf5fe0c5c65695fef6346371e9c48"
 dependencies = [
  "backtrace",
  "bytes",
@@ -2999,7 +2982,7 @@ version = "0.22.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "17b4795ff5edd201c7cd6dca065ae59972ce77d1b80fa0a84d94950ece7d1474"
 dependencies = [
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -3097,29 +3080,15 @@ dependencies = [
  "tracing-subscriber",
 ]
 
-[[package]]
-name = "tracing-log"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
-dependencies = [
- "log",
- "once_cell",
- "tracing-core",
-]
-
 [[package]]
 name = "tracing-subscriber"
 version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
 dependencies = [
- "nu-ansi-term",
  "sharded-slab",
- "smallvec",
  "thread_local",
  "tracing-core",
- "tracing-log",
 ]
 
 [[package]]
@@ -3284,28 +3253,6 @@ version = "0.25.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
 [[package]]
 name = "windows-core"
 version = "0.61.0"
@@ -3522,9 +3469,9 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "2.6.0"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "febbe83a485467affa75a75d28dc7494acd2f819e549536c47d46b3089b56164"
+checksum = "1dcb24d0152526ae49b9b96c1dcf71850ca1e0b882e4e28ed898a93c41334744"
 dependencies = [
  "aes",
  "arbitrary",
@@ -3536,7 +3483,7 @@ dependencies = [
  "flate2",
  "getrandom 0.3.2",
  "hmac",
- "indexmap 2.8.0",
+ "indexmap 2.9.0",
  "lzma-rs",
  "memchr",
  "pbkdf2",

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*"]
 package.description = "The Bitcoin Research Kit is a suite of tools designed to extract, compute and display data stored on a Bitcoin Core node"
 package.license = "MIT"
 package.edition = "2024"
-package.version = "0.0.16"
+package.version = "0.0.19"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 
 [profile.release]
@@ -12,6 +12,9 @@ lto = "fat"
 codegen-units = 1
 panic = "abort"
 
+[profile.dist]
+inherits = "release"
+
 [workspace.dependencies]
 bitcoin = { version = "0.32.5", features = ["serde"] }
 bitcoincore-rpc = "0.19.0"
@@ -39,3 +42,20 @@ serde = { version = "1.0.219", features = ["derive"] }
 serde_json = { version = "1.0.140", features = ["float_roundtrip"] }
 tabled = "0.18.0"
 zerocopy = { version = "0.8.24", features = ["derive"] }
+
+[workspace.metadata.release]
+shared-version = true
+tag-name = "v{{version}}"
+pre-release-commit-message = "release: v{{version}}"
+tag-message = "release: v{{version}}"
+
+[workspace.metadata.dist]
+cargo-dist-version = "0.28.0"
+ci = "github"
+installers = []
+targets = [
+    "aarch64-apple-darwin",
+    "aarch64-unknown-linux-gnu",
+    "x86_64-apple-darwin",
+    "x86_64-unknown-linux-gnu",
+]

crates/brk_cli/Cargo.toml

@@ -26,3 +26,6 @@ toml = "0.8.20"
 [[bin]]
 name = "brk"
 path = "src/main.rs"
+
+[package.metadata.dist]
+dist = false

crates/brk_cli/src/run.rs

@@ -61,7 +61,7 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
                 loop {
                     let block_count = rpc.get_block_count()?;
 
-                    info!("{block_count} blocks found.");
+                    info!("{} blocks found.", block_count + 1);
 
                     let starting_indexes = indexer.index(&parser, rpc, &exit)?;
 

crates/brk_computer/src/storage/stores.rs

@@ -13,9 +13,9 @@ pub struct Stores {
 impl Stores {
     pub fn import(path: &Path) -> color_eyre::Result<Self> {
         let address_to_utxos_received =
-            Store::import(&path.join("address_to_utxos_received"), Version::ONE)?;
+            Store::import(&path.join("address_to_utxos_received"), Version::ZERO)?;
         let address_to_utxos_spent =
-            Store::import(&path.join("address_to_utxos_spent"), Version::ONE)?;
+            Store::import(&path.join("address_to_utxos_spent"), Version::ZERO)?;
 
         Ok(Self {
             address_to_utxos_received,

crates/brk_computer/src/storage/vecs/base.rs

@@ -9,17 +9,19 @@ use std::{
 
 use brk_core::CheckedSub;
 use brk_exit::Exit;
-use brk_vec::{AnyStorableVec, Compressed, Error, Result, StoredIndex, StoredType, Version};
+use brk_vec::{
+    AnyStorableVec, Compressed, Error, Result, StorableVec, StoredIndex, StoredType, Version,
+};
 
 const FLUSH_EVERY: usize = 10_000;
 
 #[derive(Debug)]
-pub struct StorableVec<I, T> {
+pub struct ComputedVec<I, T> {
     computed_version: Option<Version>,
-    vec: brk_vec::StorableVec<I, T>,
+    vec: StorableVec<I, T>,
 }
 
-impl<I, T> StorableVec<I, T>
+impl<I, T> ComputedVec<I, T>
 where
     I: StoredIndex,
     T: StoredType,
@@ -29,7 +31,7 @@ where
         version: Version,
         compressed: Compressed,
     ) -> brk_vec::Result<Self> {
-        let vec = brk_vec::StorableVec::forced_import(path, version, compressed)?;
+        let vec = StorableVec::forced_import(path, version, compressed)?;
 
         Ok(Self {
             computed_version: None,
@@ -86,11 +88,11 @@ where
         self.vec.len()
     }
 
-    pub fn vec(&self) -> &brk_vec::StorableVec<I, T> {
+    pub fn vec(&self) -> &StorableVec<I, T> {
         &self.vec
     }
 
-    pub fn mut_vec(&mut self) -> &mut brk_vec::StorableVec<I, T> {
+    pub fn mut_vec(&mut self) -> &mut StorableVec<I, T> {
         &mut self.vec
     }
 
@@ -127,14 +129,14 @@ where
     pub fn compute_transform<A, B, F>(
         &mut self,
         max_from: A,
-        other: &mut brk_vec::StorableVec<A, B>,
+        other: &mut StorableVec<A, B>,
         mut t: F,
         exit: &Exit,
     ) -> Result<()>
     where
         A: StoredIndex,
         B: StoredType,
-        F: FnMut((A, B, &mut Self, &mut brk_vec::StorableVec<A, B>)) -> (I, T),
+        F: FnMut((A, B, &mut Self, &mut StorableVec<A, B>)) -> (I, T),
     {
         self.validate_computed_version_or_reset_file(
             Version::ZERO + self.version() + other.version(),
@@ -152,7 +154,7 @@ where
     pub fn compute_inverse_more_to_less(
         &mut self,
         max_from: T,
-        other: &mut brk_vec::StorableVec<T, I>,
+        other: &mut StorableVec<T, I>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -179,8 +181,8 @@ where
     pub fn compute_inverse_less_to_more(
         &mut self,
         max_from: T,
-        first_indexes: &mut brk_vec::StorableVec<T, I>,
+        first_indexes: &mut StorableVec<T, I>,
-        last_indexes: &mut brk_vec::StorableVec<T, I>,
+        last_indexes: &mut StorableVec<T, I>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -205,7 +207,7 @@ where
     pub fn compute_last_index_from_first(
         &mut self,
         max_from: I,
-        first_indexes: &mut brk_vec::StorableVec<I, T>,
+        first_indexes: &mut StorableVec<I, T>,
         final_len: usize,
         exit: &Exit,
     ) -> Result<()>
@@ -240,8 +242,8 @@ where
     pub fn compute_count_from_indexes<T2>(
         &mut self,
         max_from: I,
-        first_indexes: &mut brk_vec::StorableVec<I, T2>,
+        first_indexes: &mut StorableVec<I, T2>,
-        last_indexes: &mut brk_vec::StorableVec<I, T2>,
+        last_indexes: &mut StorableVec<I, T2>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -268,8 +270,8 @@ where
     pub fn compute_is_first_ordered<A>(
         &mut self,
         max_from: I,
-        self_to_other: &mut brk_vec::StorableVec<I, A>,
+        self_to_other: &mut StorableVec<I, A>,
-        other_to_self: &mut brk_vec::StorableVec<A, I>,
+        other_to_self: &mut StorableVec<A, I>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -292,8 +294,8 @@ where
     pub fn compute_sum_from_indexes<T2>(
         &mut self,
         max_from: I,
-        first_indexes: &mut brk_vec::StorableVec<I, T2>,
+        first_indexes: &mut StorableVec<I, T2>,
-        last_indexes: &mut brk_vec::StorableVec<I, T2>,
+        last_indexes: &mut StorableVec<I, T2>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -316,7 +318,7 @@ where
     }
 }
 
-impl<I, T> Clone for StorableVec<I, T>
+impl<I, T> Clone for ComputedVec<I, T>
 where
     I: StoredIndex,
     T: StoredType,

crates/brk_computer/src/storage/vecs/blocks.rs

@@ -1,21 +1,24 @@
 use std::{fs, path::Path};
 
-use brk_core::{CheckedSub, Dateindex, Height, Timestamp};
+use brk_core::{CheckedSub, StoredU32, StoredU64, StoredUsize, Timestamp, Weight};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
+use brk_parser::bitcoin;
 use brk_vec::{AnyStorableVec, Compressed, Version};
 
 use super::{
-    Indexes, StorableVec, indexes,
+    Indexes,
-    stats::{StorableVecGeneatorOptions, StorableVecsStatsFromHeight},
+    grouped::{ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    indexes,
 };
 
 #[derive(Clone)]
 pub struct Vecs {
-    pub height_to_block_interval: StorableVec<Height, Timestamp>,
+    pub indexes_to_block_interval: ComputedVecsFromHeight<Timestamp>,
-    pub indexes_to_block_interval_stats: StorableVecsStatsFromHeight<Timestamp>,
+    pub indexes_to_block_count: ComputedVecsFromHeight<StoredU32>,
-    pub dateindex_to_block_count: StorableVec<Dateindex, u16>,
+    pub indexes_to_block_weight: ComputedVecsFromHeight<Weight>,
-    pub dateindex_to_total_block_count: StorableVec<Dateindex, u32>,
+    pub indexes_to_block_vbytes: ComputedVecsFromHeight<StoredU64>,
+    pub indexes_to_block_size: ComputedVecsFromHeight<StoredUsize>,
 }
 
 impl Vecs {
@@ -23,28 +26,48 @@ impl Vecs {
         fs::create_dir_all(path)?;
 
         Ok(Self {
-            height_to_block_interval: StorableVec::forced_import(
+            indexes_to_block_interval: ComputedVecsFromHeight::forced_import(
-                &path.join("height_to_block_interval"),
+                path,
-                Version::ONE,
+                "block_interval",
-                compressed,
+                true,
-            )?,
+                Version::ZERO,
-            indexes_to_block_interval_stats: StorableVecsStatsFromHeight::forced_import(
-                &path.join("block_interval"),
                 compressed,
                 StorableVecGeneatorOptions::default()
                     .add_percentiles()
                     .add_minmax()
                     .add_average(),
             )?,
-            dateindex_to_block_count: StorableVec::forced_import(
+            indexes_to_block_count: ComputedVecsFromHeight::forced_import(
-                &path.join("dateindex_to_block_count"),
+                path,
-                Version::ONE,
+                "block_count",
+                true,
+                Version::ZERO,
                 compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
             )?,
-            dateindex_to_total_block_count: StorableVec::forced_import(
+            indexes_to_block_weight: ComputedVecsFromHeight::forced_import(
-                &path.join("dateindex_to_total_block_count"),
+                path,
-                Version::ONE,
+                "block_weight",
+                false,
+                Version::ZERO,
                 compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
+            )?,
+            indexes_to_block_size: ComputedVecsFromHeight::forced_import(
+                path,
+                "block_size",
+                false,
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
+            )?,
+            indexes_to_block_vbytes: ComputedVecsFromHeight::forced_import(
+                path,
+                "block_vbytes",
+                true,
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
             )?,
         })
     }
@@ -56,28 +79,78 @@ impl Vecs {
         starting_indexes: &Indexes,
         exit: &Exit,
     ) -> color_eyre::Result<()> {
-        let indexer_vecs = indexer.mut_vecs();
+        self.indexes_to_block_interval.compute_all(
-
+            indexer,
-        self.height_to_block_interval.compute_transform(
-            starting_indexes.height,
-            indexer_vecs.height_to_timestamp.mut_vec(),
-            |(height, timestamp, _, height_to_timestamp)| {
-                let interval = height.decremented().map_or(Timestamp::ZERO, |prev_h| {
-                    let prev_timestamp = *height_to_timestamp.get(prev_h).unwrap().unwrap();
-                    timestamp
-                        .checked_sub(prev_timestamp)
-                        .unwrap_or(Timestamp::ZERO)
-                });
-                (height, interval)
-            },
-            exit,
-        )?;
-
-        self.indexes_to_block_interval_stats.compute(
-            &mut self.height_to_block_interval,
             indexes,
             starting_indexes,
             exit,
+            |v, indexer, _, starting_indexes, exit| {
+                let indexer_vecs = indexer.mut_vecs();
+
+                v.compute_transform(
+                    starting_indexes.height,
+                    indexer_vecs.height_to_timestamp.mut_vec(),
+                    |(height, timestamp, _, height_to_timestamp)| {
+                        let interval = height.decremented().map_or(Timestamp::ZERO, |prev_h| {
+                            let prev_timestamp = *height_to_timestamp.get(prev_h).unwrap().unwrap();
+                            timestamp
+                                .checked_sub(prev_timestamp)
+                                .unwrap_or(Timestamp::ZERO)
+                        });
+                        (height, interval)
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_block_count.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, indexer, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    indexer.mut_vecs().height_to_block_weight.mut_vec(),
+                    |(h, ..)| (h, StoredU32::from(1_u32)),
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_block_weight.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(indexer.mut_vecs().height_to_block_weight.mut_vec()),
+        )?;
+
+        self.indexes_to_block_size.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(indexer.mut_vecs().height_to_block_size.mut_vec()),
+        )?;
+
+        self.indexes_to_block_vbytes.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, indexer, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    indexer.mut_vecs().height_to_block_weight.mut_vec(),
+                    |(h, w, ..)| {
+                        (
+                            h,
+                            StoredU64::from(bitcoin::Weight::from(w).to_vbytes_floor()),
+                        )
+                    },
+                    exit,
+                )
+            },
         )?;
 
         Ok(())
@@ -85,12 +158,11 @@ impl Vecs {
 
     pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
         [
-            vec![
+            self.indexes_to_block_interval.any_vecs(),
-                self.height_to_block_interval.any_vec(),
+            self.indexes_to_block_count.any_vecs(),
-                self.dateindex_to_block_count.any_vec(),
+            self.indexes_to_block_weight.any_vecs(),
-                self.dateindex_to_total_block_count.any_vec(),
+            self.indexes_to_block_size.any_vecs(),
-            ],
+            self.indexes_to_block_vbytes.any_vecs(),
-            self.indexes_to_block_interval_stats.as_any_vecs(),
         ]
         .concat()
     }

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

@@ -1,112 +1,162 @@
 use std::path::Path;
 
 use brk_exit::Exit;
-use brk_vec::{AnyStorableVec, Compressed, Result, StoredIndex, StoredType, Version};
+use brk_vec::{AnyStorableVec, Compressed, Result, StorableVec, StoredIndex, StoredType, Version};
 
-use crate::storage::vecs::base::StorableVec;
+use crate::storage::vecs::base::ComputedVec;
 
 use super::ComputedType;
 
 #[derive(Clone, Debug)]
-pub struct StorableVecBuilder<I, T>
+pub struct ComputedVecBuilder<I, T>
 where
     I: StoredIndex,
     T: ComputedType,
 {
-    pub first: Option<StorableVec<I, T>>,
+    pub first: Option<ComputedVec<I, T>>,
-    pub average: Option<StorableVec<I, T>>,
+    pub average: Option<ComputedVec<I, T>>,
-    pub sum: Option<StorableVec<I, T>>,
+    pub sum: Option<ComputedVec<I, T>>,
-    pub max: Option<StorableVec<I, T>>,
+    pub max: Option<ComputedVec<I, T>>,
-    pub _90p: Option<StorableVec<I, T>>,
+    pub _90p: Option<ComputedVec<I, T>>,
-    pub _75p: Option<StorableVec<I, T>>,
+    pub _75p: Option<ComputedVec<I, T>>,
-    pub median: Option<StorableVec<I, T>>,
+    pub median: Option<ComputedVec<I, T>>,
-    pub _25p: Option<StorableVec<I, T>>,
+    pub _25p: Option<ComputedVec<I, T>>,
-    pub _10p: Option<StorableVec<I, T>>,
+    pub _10p: Option<ComputedVec<I, T>>,
-    pub min: Option<StorableVec<I, T>>,
+    pub min: Option<ComputedVec<I, T>>,
-    pub last: Option<StorableVec<I, T>>,
+    pub last: Option<ComputedVec<I, T>>,
+    pub total: Option<ComputedVec<I, T>>,
 }
 
-impl<I, T> StorableVecBuilder<I, T>
+impl<I, T> ComputedVecBuilder<I, T>
 where
     I: StoredIndex,
     T: ComputedType,
 {
     pub fn forced_import(
         path: &Path,
+        name: &str,
         compressed: Compressed,
         options: StorableVecGeneatorOptions,
     ) -> color_eyre::Result<Self> {
-        let name = path.file_name().unwrap().to_str().unwrap().to_string();
         let key = I::to_string().split("::").last().unwrap().to_lowercase();
 
         let only_one_active = options.is_only_one_active();
 
-        let prefix = |s: &str| {
+        let default = || path.join(format!("{key}_to_{name}"));
+
+        let prefix = |s: &str| path.join(format!("{key}_to_{s}_{name}"));
+
+        let maybe_prefix = |s: &str| {
             if only_one_active {
-                path.with_file_name(format!("{key}_to_{name}"))
+                default()
             } else {
-                path.with_file_name(format!("{key}_to_{s}_{name}"))
+                prefix(s)
             }
         };
 
-        let suffix = |s: &str| {
+        let suffix = |s: &str| path.join(format!("{key}_to_{name}_{s}"));
+
+        let maybe_suffix = |s: &str| {
             if only_one_active {
-                path.with_file_name(format!("{key}_to_{name}"))
+                default()
             } else {
-                path.with_file_name(format!("{key}_to_{name}_{s}"))
+                suffix(s)
             }
         };
 
         let s = Self {
             first: options.first.then(|| {
-                StorableVec::forced_import(&prefix("first"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_prefix("first"), Version::ZERO, compressed)
+                    .unwrap()
             }),
             last: options.last.then(|| {
-                StorableVec::forced_import(
+                ComputedVec::forced_import(
-                    &path.with_file_name(format!("{key}_to_{name}")),
+                    &path.join(format!("{key}_to_{name}")),
-                    Version::ONE,
+                    Version::ZERO,
                     compressed,
                 )
                 .unwrap()
             }),
             min: options.min.then(|| {
-                StorableVec::forced_import(&suffix("min"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("min"), Version::ZERO, compressed).unwrap()
             }),
             max: options.max.then(|| {
-                StorableVec::forced_import(&suffix("max"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("max"), Version::ZERO, compressed).unwrap()
             }),
             median: options.median.then(|| {
-                StorableVec::forced_import(&suffix("median"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("median"), Version::ZERO, compressed)
+                    .unwrap()
             }),
             average: options.average.then(|| {
-                StorableVec::forced_import(&suffix("average"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("average"), Version::ZERO, compressed)
+                    .unwrap()
             }),
             sum: options.sum.then(|| {
-                StorableVec::forced_import(&suffix("sum"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("sum"), Version::ZERO, compressed).unwrap()
+            }),
+            total: options.total.then(|| {
+                ComputedVec::forced_import(&prefix("total"), Version::ZERO, compressed).unwrap()
             }),
             _90p: options._90p.then(|| {
-                StorableVec::forced_import(&suffix("90p"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("90p"), Version::ZERO, compressed).unwrap()
             }),
             _75p: options._75p.then(|| {
-                StorableVec::forced_import(&suffix("75p"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("75p"), Version::ZERO, compressed).unwrap()
             }),
             _25p: options._25p.then(|| {
-                StorableVec::forced_import(&suffix("25p"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("25p"), Version::ZERO, compressed).unwrap()
             }),
             _10p: options._10p.then(|| {
-                StorableVec::forced_import(&suffix("10p"), Version::ONE, compressed).unwrap()
+                ComputedVec::forced_import(&maybe_suffix("10p"), Version::ZERO, compressed).unwrap()
             }),
         };
 
         Ok(s)
     }
 
+    pub fn extend(
+        &mut self,
+        max_from: I,
+        source: &mut StorableVec<I, T>,
+        exit: &Exit,
+    ) -> Result<()> {
+        if self.total.is_none() {
+            return Ok(());
+        };
+
+        let index = self.starting_index(max_from);
+
+        let total_vec = self.total.as_mut().unwrap();
+
+        source.iter_from(index, |(i, v)| {
+            let prev = i
+                .to_usize()
+                .unwrap()
+                .checked_sub(1)
+                .map_or(T::from(0_usize), |prev_i| {
+                    total_vec
+                        .get(I::from(prev_i))
+                        .unwrap()
+                        .unwrap_or(&T::from(0_usize))
+                        .to_owned()
+                });
+            let value = v.clone() + prev;
+            total_vec.forced_push_at(i, value, exit)?;
+
+            Ok(())
+        })?;
+
+        self.safe_flush(exit)?;
+
+        Ok(())
+    }
+
     pub fn compute<I2>(
         &mut self,
         max_from: I,
         source: &mut StorableVec<I2, T>,
-        first_indexes: &mut brk_vec::StorableVec<I, I2>,
+        first_indexes: &mut StorableVec<I, I2>,
-        last_indexes: &mut brk_vec::StorableVec<I, I2>,
+        last_indexes: &mut StorableVec<I, I2>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -133,7 +183,8 @@ where
             let first_index = first_index.to_usize()?;
             let last_index = last_index.to_usize()?;
 
-            let needs_sum_or_average = self.sum.is_some() || self.average.is_some();
+            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_sorted = self.max.is_some()
                 || self._90p.is_some()
                 || self._75p.is_some()
@@ -141,7 +192,7 @@ where
                 || self._25p.is_some()
                 || self._10p.is_some()
                 || self.min.is_some();
-            let needs_values = needs_sorted || needs_sum_or_average;
+            let needs_values = needs_sorted || needs_average_sum_or_total;
 
             if needs_values {
                 let mut values =
@@ -179,7 +230,7 @@ where
                     }
                 }
 
-                if needs_sum_or_average {
+                if needs_average_sum_or_total {
                     let len = values.len();
 
                     if let Some(average) = self.average.as_mut() {
@@ -192,9 +243,22 @@ where
                         average.forced_push_at(i, avg, exit)?;
                     }
 
-                    if let Some(sum_vec) = self.sum.as_mut() {
+                    if needs_sum_or_total {
                         let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
-                        sum_vec.forced_push_at(i, sum, exit)?;
+
+                        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 prev = i.to_usize().unwrap().checked_sub(1).map_or(
+                                T::from(0_usize),
+                                |prev_i| {
+                                    total_vec.get(I::from(prev_i)).unwrap().unwrap().to_owned()
+                                },
+                            );
+                            total_vec.forced_push_at(i, prev + sum, exit)?;
+                        }
                     }
                 }
             }
@@ -211,9 +275,9 @@ where
     pub fn from_aligned<I2>(
         &mut self,
         max_from: I,
-        source: &mut StorableVecBuilder<I2, T>,
+        source: &mut ComputedVecBuilder<I2, T>,
-        first_indexes: &mut brk_vec::StorableVec<I, I2>,
+        first_indexes: &mut StorableVec<I, I2>,
-        last_indexes: &mut brk_vec::StorableVec<I, I2>,
+        last_indexes: &mut StorableVec<I, I2>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -263,9 +327,10 @@ where
             let first_index = Some(first_index.to_usize()? as i64);
             let last_index = Some(last_index.to_usize()? as i64);
 
-            let needs_sum_or_average = self.sum.is_some() || self.average.is_some();
+            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_sorted = self.max.is_some() || self.min.is_some();
-            let needs_values = needs_sorted || needs_sum_or_average;
+            let needs_values = needs_sorted || needs_average_sum_or_total;
 
             if needs_values {
                 if needs_sorted {
@@ -290,7 +355,7 @@ where
                     }
                 }
 
-                if needs_sum_or_average {
+                if needs_average_sum_or_total {
                     if let Some(average) = self.average.as_mut() {
                         let values = source
                             .average
@@ -308,14 +373,27 @@ where
                         average.forced_push_at(i, avg, exit)?;
                     }
 
-                    if let Some(sum_vec) = self.sum.as_mut() {
+                    if needs_sum_or_total {
                         let values = source
                             .sum
                             .as_ref()
                             .unwrap()
                             .collect_range(first_index, last_index)?;
                         let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
-                        sum_vec.forced_push_at(i, sum, exit)?;
+
+                        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 prev = i.to_usize().unwrap().checked_sub(1).map_or(
+                                T::from(0_usize),
+                                |prev_i| {
+                                    total_vec.get(I::from(prev_i)).unwrap().unwrap().to_owned()
+                                },
+                            );
+                            total_vec.forced_push_at(i, prev + sum, exit)?;
+                        }
                     }
                 }
             }
@@ -352,15 +430,11 @@ where
 
     fn starting_index(&self, max_from: I) -> I {
         max_from.min(I::from(
-            self.as_any_vecs()
+            self.any_vecs().into_iter().map(|v| v.len()).min().unwrap(),
-                .into_iter()
-                .map(|v| v.len())
-                .min()
-                .unwrap(),
         ))
     }
 
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
+    pub fn any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
         let mut v: Vec<&dyn AnyStorableVec> = vec![];
 
         if let Some(first) = self.first.as_ref() {
@@ -384,6 +458,9 @@ where
         if let Some(sum) = self.sum.as_ref() {
             v.push(sum.any_vec());
         }
+        if let Some(total) = self.total.as_ref() {
+            v.push(total.any_vec());
+        }
         if let Some(_90p) = self._90p.as_ref() {
             v.push(_90p.any_vec());
         }
@@ -422,6 +499,9 @@ 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(_90p) = self._90p.as_mut() {
             _90p.safe_flush(exit)?;
         }
@@ -452,6 +532,7 @@ pub struct StorableVecGeneatorOptions {
     min: bool,
     first: bool,
     last: bool,
+    total: bool,
 }
 
 impl StorableVecGeneatorOptions {
@@ -510,6 +591,11 @@ impl StorableVecGeneatorOptions {
         self
     }
 
+    pub fn add_total(mut self) -> Self {
+        self.total = true;
+        self
+    }
+
     pub fn rm_min(mut self) -> Self {
         self.min = false;
         self
@@ -555,6 +641,11 @@ impl StorableVecGeneatorOptions {
         self
     }
 
+    pub fn rm_total(mut self) -> Self {
+        self.total = false;
+        self
+    }
+
     pub fn add_minmax(mut self) -> Self {
         self.min = true;
         self.max = true;
@@ -592,10 +683,18 @@ impl StorableVecGeneatorOptions {
             self.min,
             self.first,
             self.last,
+            self.total,
         ]
         .iter()
         .filter(|b| **b)
         .count()
             == 1
     }
+
+    pub fn copy_self_extra(&self) -> Self {
+        Self {
+            total: self.total,
+            ..Self::default()
+        }
+    }
 }

crates/brk_computer/src/storage/vecs/grouped/from_dateindex.rs

@@ -0,0 +1,141 @@
+use std::path::Path;
+
+use brk_core::{Dateindex, Decadeindex, Monthindex, Quarterindex, Weekindex, Yearindex};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyStorableVec, Compressed, Result, Version};
+
+use crate::storage::vecs::{Indexes, base::ComputedVec, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromDateindex<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub dateindex: ComputedVec<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>,
+}
+
+impl<T> ComputedVecsFromDateindex<T>
+where
+    T: ComputedType + Ord + From<f64>,
+    f64: From<T>,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let dateindex_extra =
+            ComputedVecBuilder::forced_import(path, name, compressed, options.copy_self_extra())?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            dateindex: ComputedVec::forced_import(
+                &path.join(format!("dateindex_to_{name}")),
+                version,
+                compressed,
+            )?,
+            dateindex_extra,
+            weekindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            monthindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            quarterindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+        })
+    }
+
+    pub fn compute<F>(
+        &mut self,
+        indexer: &mut Indexer,
+        indexes: &mut indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(
+            &mut ComputedVec<Dateindex, T>,
+            &mut Indexer,
+            &mut indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(
+            &mut self.dateindex,
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        self.dateindex_extra
+            .extend(starting_indexes.dateindex, self.dateindex.mut_vec(), exit)?;
+
+        self.weekindex.compute(
+            starting_indexes.weekindex,
+            self.dateindex.mut_vec(),
+            indexes.weekindex_to_first_dateindex.mut_vec(),
+            indexes.weekindex_to_last_dateindex.mut_vec(),
+            exit,
+        )?;
+
+        self.monthindex.compute(
+            starting_indexes.monthindex,
+            self.dateindex.mut_vec(),
+            indexes.monthindex_to_first_dateindex.mut_vec(),
+            indexes.monthindex_to_last_dateindex.mut_vec(),
+            exit,
+        )?;
+
+        self.quarterindex.from_aligned(
+            starting_indexes.quarterindex,
+            &mut self.monthindex,
+            indexes.quarterindex_to_first_monthindex.mut_vec(),
+            indexes.quarterindex_to_last_monthindex.mut_vec(),
+            exit,
+        )?;
+
+        self.yearindex.from_aligned(
+            starting_indexes.yearindex,
+            &mut self.monthindex,
+            indexes.yearindex_to_first_monthindex.mut_vec(),
+            indexes.yearindex_to_last_monthindex.mut_vec(),
+            exit,
+        )?;
+
+        self.decadeindex.from_aligned(
+            starting_indexes.decadeindex,
+            &mut self.yearindex,
+            indexes.decadeindex_to_first_yearindex.mut_vec(),
+            indexes.decadeindex_to_last_yearindex.mut_vec(),
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
+        [
+            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()
+    }
+}

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

@@ -0,0 +1,186 @@
+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::{AnyStorableVec, Compressed, Result, StorableVec, Version};
+
+use crate::storage::vecs::{Indexes, base::ComputedVec, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromHeight<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub height: Option<ComputedVec<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>,
+}
+
+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 height = compute_source.then(|| {
+            ComputedVec::forced_import(&path.join(format!("height_to_{name}")), version, compressed)
+                .unwrap()
+        });
+
+        let height_extra =
+            ComputedVecBuilder::forced_import(path, name, compressed, options.copy_self_extra())?;
+
+        let dateindex = ComputedVecBuilder::forced_import(path, name, compressed, options)?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            height,
+            height_extra,
+            dateindex,
+            weekindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            difficultyepoch: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            monthindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            quarterindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &mut Indexer,
+        indexes: &mut indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(
+            &mut ComputedVec<Height, T>,
+            &mut Indexer,
+            &mut 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: &mut indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        height: Option<&mut StorableVec<Height, T>>,
+    ) -> color_eyre::Result<()> {
+        let height = height.unwrap_or_else(|| self.height.as_mut().unwrap().mut_vec());
+
+        self.height_extra
+            .extend(starting_indexes.height, height, exit)?;
+
+        self.dateindex.compute(
+            starting_indexes.dateindex,
+            height,
+            indexes.dateindex_to_first_height.mut_vec(),
+            indexes.dateindex_to_last_height.mut_vec(),
+            exit,
+        )?;
+
+        self.weekindex.from_aligned(
+            starting_indexes.weekindex,
+            &mut self.dateindex,
+            indexes.weekindex_to_first_dateindex.mut_vec(),
+            indexes.weekindex_to_last_dateindex.mut_vec(),
+            exit,
+        )?;
+
+        self.monthindex.from_aligned(
+            starting_indexes.monthindex,
+            &mut self.dateindex,
+            indexes.monthindex_to_first_dateindex.mut_vec(),
+            indexes.monthindex_to_last_dateindex.mut_vec(),
+            exit,
+        )?;
+
+        self.quarterindex.from_aligned(
+            starting_indexes.quarterindex,
+            &mut self.monthindex,
+            indexes.quarterindex_to_first_monthindex.mut_vec(),
+            indexes.quarterindex_to_last_monthindex.mut_vec(),
+            exit,
+        )?;
+
+        self.yearindex.from_aligned(
+            starting_indexes.yearindex,
+            &mut self.monthindex,
+            indexes.yearindex_to_first_monthindex.mut_vec(),
+            indexes.yearindex_to_last_monthindex.mut_vec(),
+            exit,
+        )?;
+
+        self.decadeindex.from_aligned(
+            starting_indexes.decadeindex,
+            &mut self.yearindex,
+            indexes.decadeindex_to_first_yearindex.mut_vec(),
+            indexes.decadeindex_to_last_yearindex.mut_vec(),
+            exit,
+        )?;
+
+        self.difficultyepoch.compute(
+            starting_indexes.difficultyepoch,
+            height,
+            indexes.difficultyepoch_to_first_height.mut_vec(),
+            indexes.difficultyepoch_to_last_height.mut_vec(),
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
+        [
+            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()
+    }
+}

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

@@ -0,0 +1,96 @@
+use std::path::Path;
+
+use brk_core::{Difficultyepoch, Height};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyStorableVec, Compressed, Result, Version};
+
+use crate::storage::vecs::{Indexes, base::ComputedVec, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromHeightStrict<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub height: ComputedVec<Height, T>,
+    pub height_extra: ComputedVecBuilder<Height, T>,
+    pub difficultyepoch: ComputedVecBuilder<Difficultyepoch, T>,
+    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
+}
+
+impl<T> ComputedVecsFromHeightStrict<T>
+where
+    T: ComputedType + Ord + From<f64>,
+    f64: From<T>,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let height = ComputedVec::forced_import(
+            &path.join(format!("height_to_{name}")),
+            version,
+            compressed,
+        )?;
+
+        let height_extra =
+            ComputedVecBuilder::forced_import(path, name, compressed, options.copy_self_extra())?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            height,
+            height_extra,
+            difficultyepoch: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, compressed, options)?,
+        })
+    }
+
+    pub fn compute<F>(
+        &mut self,
+        indexer: &mut Indexer,
+        indexes: &mut indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(
+            &mut ComputedVec<Height, T>,
+            &mut Indexer,
+            &mut indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(&mut self.height, indexer, indexes, starting_indexes, exit)?;
+
+        self.height_extra
+            .extend(starting_indexes.height, self.height.mut_vec(), exit)?;
+
+        self.difficultyepoch.compute(
+            starting_indexes.difficultyepoch,
+            self.height.mut_vec(),
+            indexes.difficultyepoch_to_first_height.mut_vec(),
+            indexes.difficultyepoch_to_last_height.mut_vec(),
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
+        [
+            vec![self.height.any_vec()],
+            self.height_extra.any_vecs(),
+            self.difficultyepoch.any_vecs(),
+            // self.halvingepoch.as_any_vecs(),
+        ]
+        .concat()
+    }
+}

crates/brk_computer/src/storage/vecs/grouped/from_txindex.rs

@@ -0,0 +1,183 @@
+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::{AnyStorableVec, Compressed, Result, Version};
+
+use crate::storage::vecs::{Indexes, base::ComputedVec, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromTxindex<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub txindex: ComputedVec<Txindex, T>,
+    pub txindex_extra: ComputedVecBuilder<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>,
+}
+
+impl<T> ComputedVecsFromTxindex<T>
+where
+    T: ComputedType + Ord + From<f64>,
+    f64: From<T>,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let txindex = ComputedVec::forced_import(
+            &path.join(format!("txindex_to_{name}")),
+            version,
+            compressed,
+        )?;
+
+        let txindex_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            compressed,
+            StorableVecGeneatorOptions::default(),
+        )?;
+
+        let height = ComputedVecBuilder::forced_import(path, name, compressed, options)?;
+        let dateindex = ComputedVecBuilder::forced_import(path, name, compressed, options)?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            txindex,
+            txindex_extra,
+            height,
+            dateindex,
+            weekindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            difficultyepoch: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            monthindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            quarterindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+        })
+    }
+
+    pub fn compute<F>(
+        &mut self,
+        indexer: &mut Indexer,
+        indexes: &mut indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(
+            &mut ComputedVec<Txindex, T>,
+            &mut Indexer,
+            &mut indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(&mut self.txindex, indexer, indexes, starting_indexes, exit)?;
+
+        self.txindex_extra
+            .extend(starting_indexes.txindex, self.txindex.mut_vec(), exit)?;
+
+        self.height.compute(
+            starting_indexes.height,
+            self.txindex.mut_vec(),
+            indexer.mut_vecs().height_to_first_txindex.mut_vec(),
+            indexes.height_to_last_txindex.mut_vec(),
+            exit,
+        )?;
+
+        self.dateindex.from_aligned(
+            starting_indexes.dateindex,
+            &mut self.height,
+            indexes.dateindex_to_first_height.mut_vec(),
+            indexes.dateindex_to_last_height.mut_vec(),
+            exit,
+        )?;
+
+        self.weekindex.from_aligned(
+            starting_indexes.weekindex,
+            &mut self.dateindex,
+            indexes.weekindex_to_first_dateindex.mut_vec(),
+            indexes.weekindex_to_last_dateindex.mut_vec(),
+            exit,
+        )?;
+
+        self.monthindex.from_aligned(
+            starting_indexes.monthindex,
+            &mut self.dateindex,
+            indexes.monthindex_to_first_dateindex.mut_vec(),
+            indexes.monthindex_to_last_dateindex.mut_vec(),
+            exit,
+        )?;
+
+        self.quarterindex.from_aligned(
+            starting_indexes.quarterindex,
+            &mut self.monthindex,
+            indexes.quarterindex_to_first_monthindex.mut_vec(),
+            indexes.quarterindex_to_last_monthindex.mut_vec(),
+            exit,
+        )?;
+
+        self.yearindex.from_aligned(
+            starting_indexes.yearindex,
+            &mut self.monthindex,
+            indexes.yearindex_to_first_monthindex.mut_vec(),
+            indexes.yearindex_to_last_monthindex.mut_vec(),
+            exit,
+        )?;
+
+        self.decadeindex.from_aligned(
+            starting_indexes.decadeindex,
+            &mut self.yearindex,
+            indexes.decadeindex_to_first_yearindex.mut_vec(),
+            indexes.decadeindex_to_last_yearindex.mut_vec(),
+            exit,
+        )?;
+
+        self.difficultyepoch.from_aligned(
+            starting_indexes.difficultyepoch,
+            &mut self.height,
+            indexes.difficultyepoch_to_first_height.mut_vec(),
+            indexes.difficultyepoch_to_last_height.mut_vec(),
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
+        [
+            vec![self.txindex.any_vec()],
+            self.txindex_extra.any_vecs(),
+            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()
+    }
+}

crates/brk_computer/src/storage/vecs/grouped/mod.rs

@@ -1,11 +1,13 @@
-mod from_date;
+mod builder;
+mod from_dateindex;
 mod from_height;
 mod from_height_strict;
-mod generic;
+mod from_txindex;
 mod stored_type;
 
-pub use from_date::*;
+pub use builder::*;
+pub use from_dateindex::*;
 pub use from_height::*;
 pub use from_height_strict::*;
-pub use generic::*;
+pub use from_txindex::*;
 pub use stored_type::*;

crates/brk_computer/src/storage/vecs/indexes.rs

@@ -8,60 +8,60 @@ use brk_exit::Exit;
 use brk_indexer::Indexer;
 use brk_vec::{AnyStorableVec, Compressed, Version};
 
-use super::StorableVec;
+use super::ComputedVec;
 
 #[derive(Clone)]
 pub struct Vecs {
     // pub height_to_last_addressindex: StorableVec<Height, Addressindex>,
     // pub height_to_last_txoutindex: StorableVec<Height, Txoutindex>,
-    pub dateindex_to_date: StorableVec<Dateindex, Date>,
+    pub dateindex_to_date: ComputedVec<Dateindex, Date>,
-    pub dateindex_to_dateindex: StorableVec<Dateindex, Dateindex>,
+    pub dateindex_to_dateindex: ComputedVec<Dateindex, Dateindex>,
-    pub dateindex_to_first_height: StorableVec<Dateindex, Height>,
+    pub dateindex_to_first_height: ComputedVec<Dateindex, Height>,
-    pub dateindex_to_last_height: StorableVec<Dateindex, Height>,
+    pub dateindex_to_last_height: ComputedVec<Dateindex, Height>,
-    pub dateindex_to_monthindex: StorableVec<Dateindex, Monthindex>,
+    pub dateindex_to_monthindex: ComputedVec<Dateindex, Monthindex>,
-    pub dateindex_to_timestamp: StorableVec<Dateindex, Timestamp>,
+    pub dateindex_to_timestamp: ComputedVec<Dateindex, Timestamp>,
-    pub dateindex_to_weekindex: StorableVec<Dateindex, Weekindex>,
+    pub dateindex_to_weekindex: ComputedVec<Dateindex, Weekindex>,
-    pub decadeindex_to_decadeindex: StorableVec<Decadeindex, Decadeindex>,
+    pub decadeindex_to_decadeindex: ComputedVec<Decadeindex, Decadeindex>,
-    pub decadeindex_to_first_yearindex: StorableVec<Decadeindex, Yearindex>,
+    pub decadeindex_to_first_yearindex: ComputedVec<Decadeindex, Yearindex>,
-    pub decadeindex_to_last_yearindex: StorableVec<Decadeindex, Yearindex>,
+    pub decadeindex_to_last_yearindex: ComputedVec<Decadeindex, Yearindex>,
-    pub decadeindex_to_timestamp: StorableVec<Decadeindex, Timestamp>,
+    pub decadeindex_to_timestamp: ComputedVec<Decadeindex, Timestamp>,
-    pub difficultyepoch_to_difficultyepoch: StorableVec<Difficultyepoch, Difficultyepoch>,
+    pub difficultyepoch_to_difficultyepoch: ComputedVec<Difficultyepoch, Difficultyepoch>,
-    pub difficultyepoch_to_first_height: StorableVec<Difficultyepoch, Height>,
+    pub difficultyepoch_to_first_height: ComputedVec<Difficultyepoch, Height>,
-    pub difficultyepoch_to_last_height: StorableVec<Difficultyepoch, Height>,
+    pub difficultyepoch_to_last_height: ComputedVec<Difficultyepoch, Height>,
-    pub difficultyepoch_to_timestamp: StorableVec<Difficultyepoch, Timestamp>,
+    pub difficultyepoch_to_timestamp: ComputedVec<Difficultyepoch, Timestamp>,
-    pub halvingepoch_to_first_height: StorableVec<Halvingepoch, Height>,
+    pub halvingepoch_to_first_height: ComputedVec<Halvingepoch, Height>,
-    pub halvingepoch_to_halvingepoch: StorableVec<Halvingepoch, Halvingepoch>,
+    pub halvingepoch_to_halvingepoch: ComputedVec<Halvingepoch, Halvingepoch>,
-    pub halvingepoch_to_last_height: StorableVec<Halvingepoch, Height>,
+    pub halvingepoch_to_last_height: ComputedVec<Halvingepoch, Height>,
-    pub halvingepoch_to_timestamp: StorableVec<Halvingepoch, Timestamp>,
+    pub halvingepoch_to_timestamp: ComputedVec<Halvingepoch, Timestamp>,
-    pub height_to_dateindex: StorableVec<Height, Dateindex>,
+    pub height_to_dateindex: ComputedVec<Height, Dateindex>,
-    pub height_to_difficultyepoch: StorableVec<Height, Difficultyepoch>,
+    pub height_to_difficultyepoch: ComputedVec<Height, Difficultyepoch>,
-    pub height_to_fixed_date: StorableVec<Height, Date>,
+    pub height_to_fixed_date: ComputedVec<Height, Date>,
-    pub height_to_fixed_timestamp: StorableVec<Height, Timestamp>,
+    pub height_to_fixed_timestamp: ComputedVec<Height, Timestamp>,
-    pub height_to_halvingepoch: StorableVec<Height, Halvingepoch>,
+    pub height_to_halvingepoch: ComputedVec<Height, Halvingepoch>,
-    pub height_to_height: StorableVec<Height, Height>,
+    pub height_to_height: ComputedVec<Height, Height>,
-    pub height_to_last_txindex: StorableVec<Height, Txindex>,
+    pub height_to_last_txindex: ComputedVec<Height, Txindex>,
-    pub height_to_real_date: StorableVec<Height, Date>,
+    pub height_to_real_date: ComputedVec<Height, Date>,
-    pub monthindex_to_first_dateindex: StorableVec<Monthindex, Dateindex>,
+    pub monthindex_to_first_dateindex: ComputedVec<Monthindex, Dateindex>,
-    pub monthindex_to_last_dateindex: StorableVec<Monthindex, Dateindex>,
+    pub monthindex_to_last_dateindex: ComputedVec<Monthindex, Dateindex>,
-    pub monthindex_to_monthindex: StorableVec<Monthindex, Monthindex>,
+    pub monthindex_to_monthindex: ComputedVec<Monthindex, Monthindex>,
-    pub monthindex_to_quarterindex: StorableVec<Monthindex, Quarterindex>,
+    pub monthindex_to_quarterindex: ComputedVec<Monthindex, Quarterindex>,
-    pub monthindex_to_timestamp: StorableVec<Monthindex, Timestamp>,
+    pub monthindex_to_timestamp: ComputedVec<Monthindex, Timestamp>,
-    pub monthindex_to_yearindex: StorableVec<Monthindex, Yearindex>,
+    pub monthindex_to_yearindex: ComputedVec<Monthindex, Yearindex>,
-    pub quarterindex_to_first_monthindex: StorableVec<Quarterindex, Monthindex>,
+    pub quarterindex_to_first_monthindex: ComputedVec<Quarterindex, Monthindex>,
-    pub quarterindex_to_last_monthindex: StorableVec<Quarterindex, Monthindex>,
+    pub quarterindex_to_last_monthindex: ComputedVec<Quarterindex, Monthindex>,
-    pub quarterindex_to_quarterindex: StorableVec<Quarterindex, Quarterindex>,
+    pub quarterindex_to_quarterindex: ComputedVec<Quarterindex, Quarterindex>,
-    pub quarterindex_to_timestamp: StorableVec<Quarterindex, Timestamp>,
+    pub quarterindex_to_timestamp: ComputedVec<Quarterindex, Timestamp>,
-    pub txindex_to_last_txinindex: StorableVec<Txindex, Txinindex>,
+    pub txindex_to_last_txinindex: ComputedVec<Txindex, Txinindex>,
-    pub txindex_to_last_txoutindex: StorableVec<Txindex, Txoutindex>,
+    pub txindex_to_last_txoutindex: ComputedVec<Txindex, Txoutindex>,
-    pub weekindex_to_first_dateindex: StorableVec<Weekindex, Dateindex>,
+    pub weekindex_to_first_dateindex: ComputedVec<Weekindex, Dateindex>,
-    pub weekindex_to_last_dateindex: StorableVec<Weekindex, Dateindex>,
+    pub weekindex_to_last_dateindex: ComputedVec<Weekindex, Dateindex>,
-    pub weekindex_to_timestamp: StorableVec<Weekindex, Timestamp>,
+    pub weekindex_to_timestamp: ComputedVec<Weekindex, Timestamp>,
-    pub weekindex_to_weekindex: StorableVec<Weekindex, Weekindex>,
+    pub weekindex_to_weekindex: ComputedVec<Weekindex, Weekindex>,
-    pub yearindex_to_decadeindex: StorableVec<Yearindex, Decadeindex>,
+    pub yearindex_to_decadeindex: ComputedVec<Yearindex, Decadeindex>,
-    pub yearindex_to_first_monthindex: StorableVec<Yearindex, Monthindex>,
+    pub yearindex_to_first_monthindex: ComputedVec<Yearindex, Monthindex>,
-    pub yearindex_to_last_monthindex: StorableVec<Yearindex, Monthindex>,
+    pub yearindex_to_last_monthindex: ComputedVec<Yearindex, Monthindex>,
-    pub yearindex_to_timestamp: StorableVec<Yearindex, Timestamp>,
+    pub yearindex_to_timestamp: ComputedVec<Yearindex, Timestamp>,
-    pub yearindex_to_yearindex: StorableVec<Yearindex, Yearindex>,
+    pub yearindex_to_yearindex: ComputedVec<Yearindex, Yearindex>,
 }
 
 impl Vecs {
@@ -69,244 +69,244 @@ impl Vecs {
         fs::create_dir_all(path)?;
 
         Ok(Self {
-            dateindex_to_date: StorableVec::forced_import(
+            dateindex_to_date: ComputedVec::forced_import(
                 &path.join("dateindex_to_date"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_dateindex: StorableVec::forced_import(
+            dateindex_to_dateindex: ComputedVec::forced_import(
                 &path.join("dateindex_to_dateindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_first_height: StorableVec::forced_import(
+            dateindex_to_first_height: ComputedVec::forced_import(
                 &path.join("dateindex_to_first_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_last_height: StorableVec::forced_import(
+            dateindex_to_last_height: ComputedVec::forced_import(
                 &path.join("dateindex_to_last_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_real_date: StorableVec::forced_import(
+            height_to_real_date: ComputedVec::forced_import(
                 &path.join("height_to_real_date"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_fixed_date: StorableVec::forced_import(
+            height_to_fixed_date: ComputedVec::forced_import(
                 &path.join("height_to_fixed_date"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_dateindex: StorableVec::forced_import(
+            height_to_dateindex: ComputedVec::forced_import(
                 &path.join("height_to_dateindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_height: StorableVec::forced_import(
+            height_to_height: ComputedVec::forced_import(
                 &path.join("height_to_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_last_txindex: StorableVec::forced_import(
+            height_to_last_txindex: ComputedVec::forced_import(
                 &path.join("height_to_last_txindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_last_txinindex: StorableVec::forced_import(
+            txindex_to_last_txinindex: ComputedVec::forced_import(
                 &path.join("txindex_to_last_txinindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_last_txoutindex: StorableVec::forced_import(
+            txindex_to_last_txoutindex: ComputedVec::forced_import(
                 &path.join("txindex_to_last_txoutindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            difficultyepoch_to_first_height: StorableVec::forced_import(
+            difficultyepoch_to_first_height: ComputedVec::forced_import(
                 &path.join("difficultyepoch_to_first_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            difficultyepoch_to_last_height: StorableVec::forced_import(
+            difficultyepoch_to_last_height: ComputedVec::forced_import(
                 &path.join("difficultyepoch_to_last_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            halvingepoch_to_first_height: StorableVec::forced_import(
+            halvingepoch_to_first_height: ComputedVec::forced_import(
                 &path.join("halvingepoch_to_first_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            halvingepoch_to_last_height: StorableVec::forced_import(
+            halvingepoch_to_last_height: ComputedVec::forced_import(
                 &path.join("halvingepoch_to_last_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            weekindex_to_first_dateindex: StorableVec::forced_import(
+            weekindex_to_first_dateindex: ComputedVec::forced_import(
                 &path.join("weekindex_to_first_dateindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            weekindex_to_last_dateindex: StorableVec::forced_import(
+            weekindex_to_last_dateindex: ComputedVec::forced_import(
                 &path.join("weekindex_to_last_dateindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            monthindex_to_first_dateindex: StorableVec::forced_import(
+            monthindex_to_first_dateindex: ComputedVec::forced_import(
                 &path.join("monthindex_to_first_dateindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            monthindex_to_last_dateindex: StorableVec::forced_import(
+            monthindex_to_last_dateindex: ComputedVec::forced_import(
                 &path.join("monthindex_to_last_dateindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            yearindex_to_first_monthindex: StorableVec::forced_import(
+            yearindex_to_first_monthindex: ComputedVec::forced_import(
                 &path.join("yearindex_to_first_monthindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            yearindex_to_last_monthindex: StorableVec::forced_import(
+            yearindex_to_last_monthindex: ComputedVec::forced_import(
                 &path.join("yearindex_to_last_monthindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            decadeindex_to_first_yearindex: StorableVec::forced_import(
+            decadeindex_to_first_yearindex: ComputedVec::forced_import(
                 &path.join("decadeindex_to_first_yearindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            decadeindex_to_last_yearindex: StorableVec::forced_import(
+            decadeindex_to_last_yearindex: ComputedVec::forced_import(
                 &path.join("decadeindex_to_last_yearindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_weekindex: StorableVec::forced_import(
+            dateindex_to_weekindex: ComputedVec::forced_import(
                 &path.join("dateindex_to_weekindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_monthindex: StorableVec::forced_import(
+            dateindex_to_monthindex: ComputedVec::forced_import(
                 &path.join("dateindex_to_monthindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            monthindex_to_yearindex: StorableVec::forced_import(
+            monthindex_to_yearindex: ComputedVec::forced_import(
                 &path.join("monthindex_to_yearindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            yearindex_to_decadeindex: StorableVec::forced_import(
+            yearindex_to_decadeindex: ComputedVec::forced_import(
                 &path.join("yearindex_to_decadeindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_difficultyepoch: StorableVec::forced_import(
+            height_to_difficultyepoch: ComputedVec::forced_import(
                 &path.join("height_to_difficultyepoch"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_halvingepoch: StorableVec::forced_import(
+            height_to_halvingepoch: ComputedVec::forced_import(
                 &path.join("height_to_halvingepoch"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            weekindex_to_weekindex: StorableVec::forced_import(
+            weekindex_to_weekindex: ComputedVec::forced_import(
                 &path.join("weekindex_to_weekindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            monthindex_to_monthindex: StorableVec::forced_import(
+            monthindex_to_monthindex: ComputedVec::forced_import(
                 &path.join("monthindex_to_monthindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            yearindex_to_yearindex: StorableVec::forced_import(
+            yearindex_to_yearindex: ComputedVec::forced_import(
                 &path.join("yearindex_to_yearindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            decadeindex_to_decadeindex: StorableVec::forced_import(
+            decadeindex_to_decadeindex: ComputedVec::forced_import(
                 &path.join("decadeindex_to_decadeindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            difficultyepoch_to_difficultyepoch: StorableVec::forced_import(
+            difficultyepoch_to_difficultyepoch: ComputedVec::forced_import(
                 &path.join("difficultyepoch_to_difficultyepoch"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            halvingepoch_to_halvingepoch: StorableVec::forced_import(
+            halvingepoch_to_halvingepoch: ComputedVec::forced_import(
                 &path.join("halvingepoch_to_halvingepoch"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_timestamp: StorableVec::forced_import(
+            dateindex_to_timestamp: ComputedVec::forced_import(
                 &path.join("dateindex_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            decadeindex_to_timestamp: StorableVec::forced_import(
+            decadeindex_to_timestamp: ComputedVec::forced_import(
                 &path.join("decadeindex_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            difficultyepoch_to_timestamp: StorableVec::forced_import(
+            difficultyepoch_to_timestamp: ComputedVec::forced_import(
                 &path.join("difficultyepoch_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            halvingepoch_to_timestamp: StorableVec::forced_import(
+            halvingepoch_to_timestamp: ComputedVec::forced_import(
                 &path.join("halvingepoch_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            monthindex_to_timestamp: StorableVec::forced_import(
+            monthindex_to_timestamp: ComputedVec::forced_import(
                 &path.join("monthindex_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            weekindex_to_timestamp: StorableVec::forced_import(
+            weekindex_to_timestamp: ComputedVec::forced_import(
                 &path.join("weekindex_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            yearindex_to_timestamp: StorableVec::forced_import(
+            yearindex_to_timestamp: ComputedVec::forced_import(
                 &path.join("yearindex_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_fixed_timestamp: StorableVec::forced_import(
+            height_to_fixed_timestamp: ComputedVec::forced_import(
                 &path.join("height_to_fixed_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            monthindex_to_quarterindex: StorableVec::forced_import(
+            monthindex_to_quarterindex: ComputedVec::forced_import(
                 &path.join("monthindex_to_quarterindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            quarterindex_to_first_monthindex: StorableVec::forced_import(
+            quarterindex_to_first_monthindex: ComputedVec::forced_import(
                 &path.join("quarterindex_to_first_monthindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            quarterindex_to_last_monthindex: StorableVec::forced_import(
+            quarterindex_to_last_monthindex: ComputedVec::forced_import(
                 &path.join("quarterindex_to_last_monthindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            quarterindex_to_quarterindex: StorableVec::forced_import(
+            quarterindex_to_quarterindex: ComputedVec::forced_import(
                 &path.join("quarterindex_to_quarterindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            quarterindex_to_timestamp: StorableVec::forced_import(
+            quarterindex_to_timestamp: ComputedVec::forced_import(
                 &path.join("quarterindex_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
         })
@@ -320,7 +320,7 @@ impl Vecs {
     ) -> color_eyre::Result<Indexes> {
         let indexer_vecs = indexer.mut_vecs();
 
-        let height_count = indexer_vecs.height_to_size.len();
+        let height_count = indexer_vecs.height_to_block_size.len();
         let txindexes_count = indexer_vecs.txindex_to_txid.len();
         let txinindexes_count = indexer_vecs.txinindex_to_txoutindex.len();
         let txoutindexes_count = indexer_vecs.txoutindex_to_addressindex.len();

crates/brk_computer/src/storage/vecs/marketprice.rs

@@ -10,249 +10,216 @@ use brk_indexer::Indexer;
 use brk_vec::{AnyStorableVec, Compressed, Version};
 
 use super::{
-    Indexes, StorableVec, indexes,
+    ComputedVec, Indexes,
-    stats::{
+    grouped::{
-        StorableVecGeneatorOptions, StorableVecsStatsFromDate, StorableVecsStatsFromHeightStrict,
+        ComputedVecsFromDateindex, ComputedVecsFromHeightStrict, StorableVecGeneatorOptions,
     },
+    indexes,
 };
 
 #[derive(Clone)]
 pub struct Vecs {
-    pub dateindex_to_close: StorableVec<Dateindex, Close<Dollars>>,
+    // pub dateindex_to_close: ComputedVec<Dateindex, Close<Dollars>>,
-    pub dateindex_to_close_in_cents: StorableVec<Dateindex, Close<Cents>>,
+    pub dateindex_to_close_in_cents: ComputedVec<Dateindex, Close<Cents>>,
-    pub dateindex_to_high: StorableVec<Dateindex, High<Dollars>>,
+    pub dateindex_to_high_in_cents: ComputedVec<Dateindex, High<Cents>>,
-    pub dateindex_to_high_in_cents: StorableVec<Dateindex, High<Cents>>,
+    pub dateindex_to_low_in_cents: ComputedVec<Dateindex, Low<Cents>>,
-    pub dateindex_to_low: StorableVec<Dateindex, Low<Dollars>>,
+    pub dateindex_to_ohlc: ComputedVec<Dateindex, OHLCDollars>,
-    pub dateindex_to_low_in_cents: StorableVec<Dateindex, Low<Cents>>,
+    pub dateindex_to_ohlc_in_cents: ComputedVec<Dateindex, OHLCCents>,
-    pub dateindex_to_ohlc: StorableVec<Dateindex, OHLCDollars>,
+    pub dateindex_to_open_in_cents: ComputedVec<Dateindex, Open<Cents>>,
-    pub dateindex_to_ohlc_in_cents: StorableVec<Dateindex, OHLCCents>,
+    pub height_to_close_in_cents: ComputedVec<Height, Close<Cents>>,
-    pub dateindex_to_open: StorableVec<Dateindex, Open<Dollars>>,
+    pub height_to_high_in_cents: ComputedVec<Height, High<Cents>>,
-    pub dateindex_to_open_in_cents: StorableVec<Dateindex, Open<Cents>>,
+    pub height_to_low_in_cents: ComputedVec<Height, Low<Cents>>,
-    pub dateindex_to_sats_per_dollar: StorableVec<Dateindex, Close<Sats>>,
+    pub height_to_ohlc: ComputedVec<Height, OHLCDollars>,
-    pub height_to_close: StorableVec<Height, Close<Dollars>>,
+    pub height_to_ohlc_in_cents: ComputedVec<Height, OHLCCents>,
-    pub height_to_close_in_cents: StorableVec<Height, Close<Cents>>,
+    pub height_to_open_in_cents: ComputedVec<Height, Open<Cents>>,
-    pub height_to_high: StorableVec<Height, High<Dollars>>,
+    pub timeindexes_to_close: ComputedVecsFromDateindex<Close<Dollars>>,
-    pub height_to_high_in_cents: StorableVec<Height, High<Cents>>,
+    pub timeindexes_to_high: ComputedVecsFromDateindex<High<Dollars>>,
-    pub height_to_low: StorableVec<Height, Low<Dollars>>,
+    pub timeindexes_to_low: ComputedVecsFromDateindex<Low<Dollars>>,
-    pub height_to_low_in_cents: StorableVec<Height, Low<Cents>>,
+    pub timeindexes_to_open: ComputedVecsFromDateindex<Open<Dollars>>,
-    pub height_to_ohlc: StorableVec<Height, OHLCDollars>,
+    pub timeindexes_to_sats_per_dollar: ComputedVecsFromDateindex<Close<Sats>>,
-    pub height_to_ohlc_in_cents: StorableVec<Height, OHLCCents>,
+    pub chainindexes_to_close: ComputedVecsFromHeightStrict<Close<Dollars>>,
-    pub height_to_open: StorableVec<Height, Open<Dollars>>,
+    pub chainindexes_to_high: ComputedVecsFromHeightStrict<High<Dollars>>,
-    pub height_to_open_in_cents: StorableVec<Height, Open<Cents>>,
+    pub chainindexes_to_low: ComputedVecsFromHeightStrict<Low<Dollars>>,
-    pub height_to_sats_per_dollar: StorableVec<Height, Close<Sats>>,
+    pub chainindexes_to_open: ComputedVecsFromHeightStrict<Open<Dollars>>,
-    pub timeindexes_to_close: StorableVecsStatsFromDate<Close<Dollars>>,
+    pub chainindexes_to_sats_per_dollar: ComputedVecsFromHeightStrict<Close<Sats>>,
-    pub timeindexes_to_high: StorableVecsStatsFromDate<High<Dollars>>,
+    pub weekindex_to_ohlc: ComputedVec<Weekindex, OHLCDollars>,
-    pub timeindexes_to_low: StorableVecsStatsFromDate<Low<Dollars>>,
+    pub difficultyepoch_to_ohlc: ComputedVec<Difficultyepoch, OHLCDollars>,
-    pub timeindexes_to_open: StorableVecsStatsFromDate<Open<Dollars>>,
+    pub monthindex_to_ohlc: ComputedVec<Monthindex, OHLCDollars>,
-    pub timeindexes_to_sats_per_dollar: StorableVecsStatsFromDate<Close<Sats>>,
+    pub quarterindex_to_ohlc: ComputedVec<Quarterindex, OHLCDollars>,
-    pub chainindexes_to_close: StorableVecsStatsFromHeightStrict<Close<Dollars>>,
+    pub yearindex_to_ohlc: ComputedVec<Yearindex, OHLCDollars>,
-    pub chainindexes_to_high: StorableVecsStatsFromHeightStrict<High<Dollars>>,
-    pub chainindexes_to_low: StorableVecsStatsFromHeightStrict<Low<Dollars>>,
-    pub chainindexes_to_open: StorableVecsStatsFromHeightStrict<Open<Dollars>>,
-    pub chainindexes_to_sats_per_dollar: StorableVecsStatsFromHeightStrict<Close<Sats>>,
-    pub weekindex_to_ohlc: StorableVec<Weekindex, OHLCDollars>,
-    pub difficultyepoch_to_ohlc: StorableVec<Difficultyepoch, OHLCDollars>,
-    pub monthindex_to_ohlc: StorableVec<Monthindex, OHLCDollars>,
-    pub quarterindex_to_ohlc: StorableVec<Quarterindex, OHLCDollars>,
-    pub yearindex_to_ohlc: StorableVec<Yearindex, OHLCDollars>,
     // pub halvingepoch_to_ohlc: StorableVec<Halvingepoch, OHLCDollars>,
-    pub decadeindex_to_ohlc: StorableVec<Decadeindex, OHLCDollars>,
+    pub decadeindex_to_ohlc: ComputedVec<Decadeindex, OHLCDollars>,
 }
 
 impl Vecs {
     pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
         fs::create_dir_all(path)?;
 
+        let mut fetched_path = path.to_owned();
+        fetched_path.pop();
+        fetched_path.pop();
+        fetched_path = fetched_path.join("fetched/vecs");
+
         Ok(Self {
-            dateindex_to_ohlc_in_cents: StorableVec::forced_import(
+            dateindex_to_ohlc_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_ohlc_in_cents"),
+                &fetched_path.join("dateindex_to_ohlc_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_ohlc: StorableVec::forced_import(
+            dateindex_to_ohlc: ComputedVec::forced_import(
                 &path.join("dateindex_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_close_in_cents: StorableVec::forced_import(
+            dateindex_to_close_in_cents: ComputedVec::forced_import(
                 &path.join("dateindex_to_close_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_close: StorableVec::forced_import(
+            dateindex_to_high_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_close"),
-                Version::ONE,
-                compressed,
-            )?,
-            dateindex_to_high_in_cents: StorableVec::forced_import(
                 &path.join("dateindex_to_high_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_high: StorableVec::forced_import(
+            dateindex_to_low_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_high"),
-                Version::ONE,
-                compressed,
-            )?,
-            dateindex_to_low_in_cents: StorableVec::forced_import(
                 &path.join("dateindex_to_low_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_low: StorableVec::forced_import(
+            dateindex_to_open_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_low"),
-                Version::ONE,
-                compressed,
-            )?,
-            dateindex_to_open_in_cents: StorableVec::forced_import(
                 &path.join("dateindex_to_open_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_open: StorableVec::forced_import(
+            height_to_ohlc_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_open"),
+                &fetched_path.join("height_to_ohlc_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_sats_per_dollar: StorableVec::forced_import(
+            height_to_ohlc: ComputedVec::forced_import(
-                &path.join("dateindex_to_sats_per_dollar"),
-                Version::ONE,
-                compressed,
-            )?,
-            height_to_ohlc_in_cents: StorableVec::forced_import(
-                &path.join("height_to_ohlc_in_cents"),
-                Version::ONE,
-                compressed,
-            )?,
-            height_to_ohlc: StorableVec::forced_import(
                 &path.join("height_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_close_in_cents: StorableVec::forced_import(
+            height_to_close_in_cents: ComputedVec::forced_import(
                 &path.join("height_to_close_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_close: StorableVec::forced_import(
+            height_to_high_in_cents: ComputedVec::forced_import(
-                &path.join("height_to_close"),
-                Version::ONE,
-                compressed,
-            )?,
-            height_to_high_in_cents: StorableVec::forced_import(
                 &path.join("height_to_high_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_high: StorableVec::forced_import(
+            height_to_low_in_cents: ComputedVec::forced_import(
-                &path.join("height_to_high"),
-                Version::ONE,
-                compressed,
-            )?,
-            height_to_low_in_cents: StorableVec::forced_import(
                 &path.join("height_to_low_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_low: StorableVec::forced_import(
+            height_to_open_in_cents: ComputedVec::forced_import(
-                &path.join("height_to_low"),
-                Version::ONE,
-                compressed,
-            )?,
-            height_to_open_in_cents: StorableVec::forced_import(
                 &path.join("height_to_open_in_cents"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_open: StorableVec::forced_import(
+            timeindexes_to_open: ComputedVecsFromDateindex::forced_import(
-                &path.join("height_to_open"),
+                path,
-                Version::ONE,
+                "open",
-                compressed,
+                Version::ZERO,
-            )?,
-            height_to_sats_per_dollar: StorableVec::forced_import(
-                &path.join("height_to_sats_per_dollar"),
-                Version::ONE,
-                compressed,
-            )?,
-            timeindexes_to_open: StorableVecsStatsFromDate::forced_import(
-                &path.join("open"),
                 compressed,
                 StorableVecGeneatorOptions::default().add_first(),
             )?,
-            timeindexes_to_high: StorableVecsStatsFromDate::forced_import(
+            timeindexes_to_high: ComputedVecsFromDateindex::forced_import(
-                &path.join("high"),
+                path,
+                "high",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_max(),
             )?,
-            timeindexes_to_low: StorableVecsStatsFromDate::forced_import(
+            timeindexes_to_low: ComputedVecsFromDateindex::forced_import(
-                &path.join("low"),
+                path,
+                "low",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_min(),
             )?,
-            timeindexes_to_close: StorableVecsStatsFromDate::forced_import(
+            timeindexes_to_close: ComputedVecsFromDateindex::forced_import(
-                &path.join("close"),
+                path,
+                "close",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_last(),
             )?,
-            timeindexes_to_sats_per_dollar: StorableVecsStatsFromDate::forced_import(
+            timeindexes_to_sats_per_dollar: ComputedVecsFromDateindex::forced_import(
-                &path.join("sats_per_dollar"),
+                path,
+                "sats_per_dollar",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_last(),
             )?,
-            chainindexes_to_open: StorableVecsStatsFromHeightStrict::forced_import(
+            chainindexes_to_open: ComputedVecsFromHeightStrict::forced_import(
-                &path.join("open"),
+                path,
+                "open",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_first(),
             )?,
-            chainindexes_to_high: StorableVecsStatsFromHeightStrict::forced_import(
+            chainindexes_to_high: ComputedVecsFromHeightStrict::forced_import(
-                &path.join("high"),
+                path,
+                "high",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_max(),
             )?,
-            chainindexes_to_low: StorableVecsStatsFromHeightStrict::forced_import(
+            chainindexes_to_low: ComputedVecsFromHeightStrict::forced_import(
-                &path.join("low"),
+                path,
+                "low",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_min(),
             )?,
-            chainindexes_to_close: StorableVecsStatsFromHeightStrict::forced_import(
+            chainindexes_to_close: ComputedVecsFromHeightStrict::forced_import(
-                &path.join("close"),
+                path,
+                "close",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_last(),
             )?,
-            chainindexes_to_sats_per_dollar: StorableVecsStatsFromHeightStrict::forced_import(
+            chainindexes_to_sats_per_dollar: ComputedVecsFromHeightStrict::forced_import(
-                &path.join("sats_per_dollar"),
+                path,
+                "sats_per_dollar",
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default().add_last(),
             )?,
-            weekindex_to_ohlc: StorableVec::forced_import(
+            weekindex_to_ohlc: ComputedVec::forced_import(
                 &path.join("weekindex_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            difficultyepoch_to_ohlc: StorableVec::forced_import(
+            difficultyepoch_to_ohlc: ComputedVec::forced_import(
                 &path.join("difficultyepoch_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            monthindex_to_ohlc: StorableVec::forced_import(
+            monthindex_to_ohlc: ComputedVec::forced_import(
                 &path.join("monthindex_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            quarterindex_to_ohlc: StorableVec::forced_import(
+            quarterindex_to_ohlc: ComputedVec::forced_import(
                 &path.join("quarterindex_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            yearindex_to_ohlc: StorableVec::forced_import(
+            yearindex_to_ohlc: ComputedVec::forced_import(
                 &path.join("yearindex_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            // halvingepoch_to_ohlc: StorableVec::forced_import(&path.join("halvingepoch_to_ohlc"), Version::ONE, compressed)?,
+            // halvingepoch_to_ohlc: StorableVec::forced_import(&path.join("halvingepoch_to_ohlc"), Version::ZERO, compressed)?,
-            decadeindex_to_ohlc: StorableVec::forced_import(
+            decadeindex_to_ohlc: ComputedVec::forced_import(
                 &path.join("decadeindex_to_ohlc"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
         })
@@ -320,41 +287,6 @@ impl Vecs {
             exit,
         )?;
 
-        self.height_to_open.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.open),
-            exit,
-        )?;
-
-        self.height_to_high.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.high),
-            exit,
-        )?;
-
-        self.height_to_low.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.low),
-            exit,
-        )?;
-
-        self.height_to_close.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.close),
-            exit,
-        )?;
-
-        self.height_to_sats_per_dollar.compute_transform(
-            starting_indexes.height,
-            self.height_to_close.mut_vec(),
-            |(di, close, ..)| (di, Close::from(Sats::ONE_BTC / *close)),
-            exit,
-        )?;
-
         self.dateindex_to_ohlc_in_cents.compute_transform(
             starting_indexes.dateindex,
             indexes.dateindex_to_date.mut_vec(),
@@ -400,95 +332,124 @@ impl Vecs {
             exit,
         )?;
 
-        self.dateindex_to_open.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.open),
-            exit,
-        )?;
-
-        self.dateindex_to_high.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.high),
-            exit,
-        )?;
-
-        self.dateindex_to_low.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.low),
-            exit,
-        )?;
-
-        self.dateindex_to_close.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.close),
-            exit,
-        )?;
-
-        self.dateindex_to_sats_per_dollar.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_close.mut_vec(),
-            |(di, close, ..)| (di, Close::from(Sats::ONE_BTC / *close)),
-            exit,
-        )?;
-
         self.timeindexes_to_close.compute(
-            &mut self.dateindex_to_close,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    self.dateindex_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.close),
+                    exit,
+                )
+            },
         )?;
 
         self.timeindexes_to_high.compute(
-            &mut self.dateindex_to_high,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    self.dateindex_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.high),
+                    exit,
+                )
+            },
         )?;
 
         self.timeindexes_to_low.compute(
-            &mut self.dateindex_to_low,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    self.dateindex_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.low),
+                    exit,
+                )
+            },
         )?;
 
         self.timeindexes_to_open.compute(
-            &mut self.dateindex_to_open,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    self.dateindex_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.open),
+                    exit,
+                )
+            },
         )?;
 
         self.chainindexes_to_close.compute(
-            &mut self.height_to_close,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    self.height_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.close),
+                    exit,
+                )
+            },
         )?;
 
         self.chainindexes_to_high.compute(
-            &mut self.height_to_high,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    self.height_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.high),
+                    exit,
+                )
+            },
         )?;
 
         self.chainindexes_to_low.compute(
-            &mut self.height_to_low,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    self.height_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.low),
+                    exit,
+                )
+            },
         )?;
 
         self.chainindexes_to_open.compute(
-            &mut self.height_to_open,
+            indexer,
             indexes,
             starting_indexes,
             exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    self.height_to_ohlc.mut_vec(),
+                    |(di, ohlc, ..)| (di, ohlc.open),
+                    exit,
+                )
+            },
         )?;
 
         self.weekindex_to_ohlc.compute_transform(
@@ -771,34 +732,54 @@ impl Vecs {
             exit,
         )?;
 
+        self.chainindexes_to_sats_per_dollar.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    self.chainindexes_to_close.height.mut_vec(),
+                    |(i, close, ..)| (i, Close::from(Sats::ONE_BTC / *close)),
+                    exit,
+                )
+            },
+        )?;
+
+        self.timeindexes_to_sats_per_dollar.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    self.timeindexes_to_close.dateindex.mut_vec(),
+                    |(i, close, ..)| (i, Close::from(Sats::ONE_BTC / *close)),
+                    exit,
+                )
+            },
+        )?;
+
         Ok(())
     }
 
     pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
         vec![
             vec![
-                self.dateindex_to_close.any_vec(),
                 self.dateindex_to_close_in_cents.any_vec(),
-                self.dateindex_to_high.any_vec(),
                 self.dateindex_to_high_in_cents.any_vec(),
-                self.dateindex_to_low.any_vec(),
                 self.dateindex_to_low_in_cents.any_vec(),
                 self.dateindex_to_ohlc.any_vec(),
                 self.dateindex_to_ohlc_in_cents.any_vec(),
-                self.dateindex_to_open.any_vec(),
                 self.dateindex_to_open_in_cents.any_vec(),
-                self.dateindex_to_sats_per_dollar.any_vec(),
-                self.height_to_close.any_vec(),
                 self.height_to_close_in_cents.any_vec(),
-                self.height_to_high.any_vec(),
                 self.height_to_high_in_cents.any_vec(),
-                self.height_to_low.any_vec(),
                 self.height_to_low_in_cents.any_vec(),
                 self.height_to_ohlc.any_vec(),
                 self.height_to_ohlc_in_cents.any_vec(),
-                self.height_to_open.any_vec(),
                 self.height_to_open_in_cents.any_vec(),
-                self.height_to_sats_per_dollar.any_vec(),
                 self.weekindex_to_ohlc.any_vec(),
                 self.difficultyepoch_to_ohlc.any_vec(),
                 self.monthindex_to_ohlc.any_vec(),
@@ -807,14 +788,16 @@ impl Vecs {
                 // self.halvingepoch_to_ohlc.any_vec(),
                 self.decadeindex_to_ohlc.any_vec(),
             ],
-            self.timeindexes_to_close.as_any_vecs(),
+            self.chainindexes_to_sats_per_dollar.any_vecs(),
-            self.timeindexes_to_high.as_any_vecs(),
+            self.timeindexes_to_sats_per_dollar.any_vecs(),
-            self.timeindexes_to_low.as_any_vecs(),
+            self.timeindexes_to_close.any_vecs(),
-            self.timeindexes_to_open.as_any_vecs(),
+            self.timeindexes_to_high.any_vecs(),
-            self.chainindexes_to_close.as_any_vecs(),
+            self.timeindexes_to_low.any_vecs(),
-            self.chainindexes_to_high.as_any_vecs(),
+            self.timeindexes_to_open.any_vecs(),
-            self.chainindexes_to_low.as_any_vecs(),
+            self.chainindexes_to_close.any_vecs(),
-            self.chainindexes_to_open.as_any_vecs(),
+            self.chainindexes_to_high.any_vecs(),
+            self.chainindexes_to_low.any_vecs(),
+            self.chainindexes_to_open.any_vecs(),
         ]
         .concat()
     }

crates/brk_computer/src/storage/vecs/mod.rs

@@ -7,9 +7,9 @@ use brk_vec::{AnyStorableVec, Compressed};
 
 mod base;
 mod blocks;
+mod grouped;
 mod indexes;
 mod marketprice;
-mod stats;
 mod transactions;
 
 use base::*;

crates/brk_computer/src/storage/vecs/stats/from_date.rs

@@ -1,104 +0,0 @@
-use std::path::Path;
-
-use brk_core::{Dateindex, Decadeindex, Monthindex, Quarterindex, Weekindex, Yearindex};
-use brk_exit::Exit;
-use brk_vec::{AnyStorableVec, Compressed};
-
-use crate::storage::vecs::{Indexes, base::StorableVec, indexes};
-
-use super::{ComputedType, StorableVecBuilder, StorableVecGeneatorOptions};
-
-#[derive(Clone)]
-pub struct StorableVecsStatsFromDate<T>
-where
-    T: ComputedType + PartialOrd,
-{
-    pub weekindex: StorableVecBuilder<Weekindex, T>,
-    pub monthindex: StorableVecBuilder<Monthindex, T>,
-    pub quarterindex: StorableVecBuilder<Quarterindex, T>,
-    pub yearindex: StorableVecBuilder<Yearindex, T>,
-    pub decadeindex: StorableVecBuilder<Decadeindex, T>,
-}
-
-impl<T> StorableVecsStatsFromDate<T>
-where
-    T: ComputedType + Ord + From<f64>,
-    f64: From<T>,
-{
-    pub fn forced_import(
-        path: &Path,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let options = options.remove_percentiles();
-
-        Ok(Self {
-            weekindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            monthindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            quarterindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            yearindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            decadeindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-        })
-    }
-
-    pub fn compute(
-        &mut self,
-        source: &mut StorableVec<Dateindex, T>,
-        indexes: &mut indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        self.weekindex.compute(
-            starting_indexes.weekindex,
-            source,
-            indexes.weekindex_to_first_dateindex.mut_vec(),
-            indexes.weekindex_to_last_dateindex.mut_vec(),
-            exit,
-        )?;
-
-        self.monthindex.compute(
-            starting_indexes.monthindex,
-            source,
-            indexes.monthindex_to_first_dateindex.mut_vec(),
-            indexes.monthindex_to_last_dateindex.mut_vec(),
-            exit,
-        )?;
-
-        self.quarterindex.from_aligned(
-            starting_indexes.quarterindex,
-            &mut self.monthindex,
-            indexes.quarterindex_to_first_monthindex.mut_vec(),
-            indexes.quarterindex_to_last_monthindex.mut_vec(),
-            exit,
-        )?;
-
-        self.yearindex.from_aligned(
-            starting_indexes.yearindex,
-            &mut self.monthindex,
-            indexes.yearindex_to_first_monthindex.mut_vec(),
-            indexes.yearindex_to_last_monthindex.mut_vec(),
-            exit,
-        )?;
-
-        self.decadeindex.from_aligned(
-            starting_indexes.decadeindex,
-            &mut self.yearindex,
-            indexes.decadeindex_to_first_yearindex.mut_vec(),
-            indexes.decadeindex_to_last_yearindex.mut_vec(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
-        [
-            self.weekindex.as_any_vecs(),
-            self.monthindex.as_any_vecs(),
-            self.quarterindex.as_any_vecs(),
-            self.yearindex.as_any_vecs(),
-            self.decadeindex.as_any_vecs(),
-        ]
-        .concat()
-    }
-}

crates/brk_computer/src/storage/vecs/stats/from_height.rs

@@ -1,133 +0,0 @@
-use std::path::Path;
-
-use brk_core::{
-    Dateindex, Decadeindex, Difficultyepoch, Height, Monthindex, Quarterindex, Weekindex, Yearindex,
-};
-use brk_exit::Exit;
-use brk_vec::{AnyStorableVec, Compressed};
-
-use crate::storage::vecs::{Indexes, base::StorableVec, indexes};
-
-use super::{ComputedType, StorableVecBuilder, StorableVecGeneatorOptions};
-
-#[derive(Clone)]
-pub struct StorableVecsStatsFromHeight<T>
-where
-    T: ComputedType + PartialOrd,
-{
-    pub dateindex: StorableVecBuilder<Dateindex, T>,
-    pub weekindex: StorableVecBuilder<Weekindex, T>,
-    pub difficultyepoch: StorableVecBuilder<Difficultyepoch, T>,
-    pub monthindex: StorableVecBuilder<Monthindex, T>,
-    pub quarterindex: StorableVecBuilder<Quarterindex, T>,
-    pub yearindex: StorableVecBuilder<Yearindex, T>,
-    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
-    pub decadeindex: StorableVecBuilder<Decadeindex, T>,
-}
-
-impl<T> StorableVecsStatsFromHeight<T>
-where
-    T: ComputedType + Ord + From<f64>,
-    f64: From<T>,
-{
-    pub fn forced_import(
-        path: &Path,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let dateindex = StorableVecBuilder::forced_import(path, compressed, options)?;
-
-        let options = options.remove_percentiles();
-
-        Ok(Self {
-            dateindex,
-            weekindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            difficultyepoch: StorableVecBuilder::forced_import(path, compressed, options)?,
-            monthindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            quarterindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            yearindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-            // halvingepoch: StorableVecGeneator::forced_import(path, compressed, options)?,
-            decadeindex: StorableVecBuilder::forced_import(path, compressed, options)?,
-        })
-    }
-
-    pub fn compute(
-        &mut self,
-        source: &mut StorableVec<Height, T>,
-        indexes: &mut indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        self.dateindex.compute(
-            starting_indexes.dateindex,
-            source,
-            indexes.dateindex_to_first_height.mut_vec(),
-            indexes.dateindex_to_last_height.mut_vec(),
-            exit,
-        )?;
-
-        self.weekindex.from_aligned(
-            starting_indexes.weekindex,
-            &mut self.dateindex,
-            indexes.weekindex_to_first_dateindex.mut_vec(),
-            indexes.weekindex_to_last_dateindex.mut_vec(),
-            exit,
-        )?;
-
-        self.monthindex.from_aligned(
-            starting_indexes.monthindex,
-            &mut self.dateindex,
-            indexes.monthindex_to_first_dateindex.mut_vec(),
-            indexes.monthindex_to_last_dateindex.mut_vec(),
-            exit,
-        )?;
-
-        self.quarterindex.from_aligned(
-            starting_indexes.quarterindex,
-            &mut self.monthindex,
-            indexes.quarterindex_to_first_monthindex.mut_vec(),
-            indexes.quarterindex_to_last_monthindex.mut_vec(),
-            exit,
-        )?;
-
-        self.yearindex.from_aligned(
-            starting_indexes.yearindex,
-            &mut self.monthindex,
-            indexes.yearindex_to_first_monthindex.mut_vec(),
-            indexes.yearindex_to_last_monthindex.mut_vec(),
-            exit,
-        )?;
-
-        self.decadeindex.from_aligned(
-            starting_indexes.decadeindex,
-            &mut self.yearindex,
-            indexes.decadeindex_to_first_yearindex.mut_vec(),
-            indexes.decadeindex_to_last_yearindex.mut_vec(),
-            exit,
-        )?;
-
-        self.difficultyepoch.compute(
-            starting_indexes.difficultyepoch,
-            source,
-            indexes.difficultyepoch_to_first_height.mut_vec(),
-            indexes.difficultyepoch_to_last_height.mut_vec(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
-        [
-            self.dateindex.as_any_vecs(),
-            self.weekindex.as_any_vecs(),
-            self.difficultyepoch.as_any_vecs(),
-            self.monthindex.as_any_vecs(),
-            self.quarterindex.as_any_vecs(),
-            self.yearindex.as_any_vecs(),
-            // self.halvingepoch.as_any_vecs(),
-            self.decadeindex.as_any_vecs(),
-        ]
-        .concat()
-    }
-}

crates/brk_computer/src/storage/vecs/stats/from_height_strict.rs

@@ -1,63 +0,0 @@
-use std::path::Path;
-
-use brk_core::{Difficultyepoch, Height};
-use brk_exit::Exit;
-use brk_vec::{AnyStorableVec, Compressed};
-
-use crate::storage::vecs::{Indexes, base::StorableVec, indexes};
-
-use super::{ComputedType, StorableVecBuilder, StorableVecGeneatorOptions};
-
-#[derive(Clone)]
-pub struct StorableVecsStatsFromHeightStrict<T>
-where
-    T: ComputedType + PartialOrd,
-{
-    pub difficultyepoch: StorableVecBuilder<Difficultyepoch, T>,
-    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
-}
-
-impl<T> StorableVecsStatsFromHeightStrict<T>
-where
-    T: ComputedType + Ord + From<f64>,
-    f64: From<T>,
-{
-    pub fn forced_import(
-        path: &Path,
-        compressed: Compressed,
-        options: StorableVecGeneatorOptions,
-    ) -> color_eyre::Result<Self> {
-        let options = options.remove_percentiles();
-
-        Ok(Self {
-            difficultyepoch: StorableVecBuilder::forced_import(path, compressed, options)?,
-            // halvingepoch: StorableVecGeneator::forced_import(path, compressed, options)?,
-        })
-    }
-
-    pub fn compute(
-        &mut self,
-        source: &mut StorableVec<Height, T>,
-        indexes: &mut indexes::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        self.difficultyepoch.compute(
-            starting_indexes.difficultyepoch,
-            source,
-            indexes.difficultyepoch_to_first_height.mut_vec(),
-            indexes.difficultyepoch_to_last_height.mut_vec(),
-            exit,
-        )?;
-
-        Ok(())
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
-        [
-            self.difficultyepoch.as_any_vecs(),
-            // self.halvingepoch.as_any_vecs(),
-        ]
-        .concat()
-    }
-}

crates/brk_computer/src/storage/vecs/transactions.rs

@@ -1,31 +1,35 @@
 use std::{fs, path::Path};
 
-use brk_core::Txindex;
+use brk_core::{StoredU64, Txindex};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
 use brk_vec::{AnyStorableVec, Compressed, Version};
 
-use super::{Indexes, StorableVec, indexes};
+use super::{
+    ComputedVec, Indexes,
+    grouped::{ComputedVecsFromTxindex, StorableVecGeneatorOptions},
+    indexes,
+};
 
 #[derive(Clone)]
 pub struct Vecs {
-    // pub height_to_fee: StorableVec<Txindex, Sats>,
+    // pub height_to_fee: ComputedVec<Txindex, Sats>,
-    // pub height_to_inputcount: StorableVec<Height, u32>,
+    // pub height_to_inputcount: ComputedVec<Height, u32>,
-    // pub height_to_maxfeerate: StorableVec<Height, Feerate>,
+    // pub height_to_maxfeerate: ComputedVec<Height, Feerate>,
-    // pub height_to_medianfeerate: StorableVec<Height, Feerate>,
+    // pub height_to_medianfeerate: ComputedVec<Height, Feerate>,
-    // pub height_to_minfeerate: StorableVec<Height, Feerate>,
+    // pub height_to_minfeerate: ComputedVec<Height, Feerate>,
-    // pub height_to_outputcount: StorableVec<Height, u32>,
+    // pub height_to_outputcount: ComputedVec<Height, u32>,
-    // pub height_to_subsidy: StorableVec<Height, u32>,
+    // pub height_to_subsidy: ComputedVec<Height, u32>,
-    // pub height_to_totalfees: StorableVec<Height, Sats>,
+    // pub height_to_totalfees: ComputedVec<Height, Sats>,
-    // pub height_to_txcount: StorableVec<Height, u32>,
+    // pub height_to_txcount: ComputedVec<Height, u32>,
-    // pub txindex_to_fee: StorableVec<Txindex, Sats>,
+    // pub txindex_to_fee: ComputedVec<Txindex, Sats>,
-    pub txindex_to_is_coinbase: StorableVec<Txindex, bool>,
+    pub txindex_to_is_coinbase: ComputedVec<Txindex, bool>,
-    // pub txindex_to_feerate: StorableVec<Txindex, Feerate>,
+    // pub txindex_to_feerate: ComputedVec<Txindex, Feerate>,
-    pub txindex_to_inputs_count: StorableVec<Txindex, u32>,
+    pub txindex_to_input_count: ComputedVecsFromTxindex<StoredU64>,
-    // pub txindex_to_inputs_sum: StorableVec<Txindex, Sats>,
+    // pub txindex_to_input_sum: ComputedVec<Txindex, Sats>,
-    pub txindex_to_outputs_count: StorableVec<Txindex, u32>,
+    pub txindex_to_output_count: ComputedVecsFromTxindex<StoredU64>,
-    // pub txindex_to_outputs_sum: StorableVec<Txindex, Sats>,
+    // pub txindex_to_output_sum: ComputedVec<Txindex, Sats>,
-    // pub txinindex_to_value: StorableVec<Txinindex, Sats>,
+    // pub txinindex_to_value: ComputedVec<Txinindex, Sats>,
 }
 
 impl Vecs {
@@ -33,52 +37,48 @@ impl Vecs {
         fs::create_dir_all(path)?;
 
         Ok(Self {
-            // height_to_fee: StorableVec::forced_import(&path.join("height_to_fee"), Version::ONE)?,
+            // height_to_fee: StorableVec::forced_import(&path.join("height_to_fee"), Version::ZERO)?,
             // height_to_input_count: StorableVec::forced_import(
             //     &path.join("height_to_input_count"),
-            //     Version::ONE,
+            //     Version::ZERO,
             // )?,
-            // height_to_maxfeerate: StorableVec::forced_import(&path.join("height_to_maxfeerate"), Version::ONE)?,
+            // height_to_maxfeerate: StorableVec::forced_import(&path.join("height_to_maxfeerate"), Version::ZERO)?,
-            // height_to_medianfeerate: StorableVec::forced_import(&path.join("height_to_medianfeerate"), Version::ONE)?,
+            // height_to_medianfeerate: StorableVec::forced_import(&path.join("height_to_medianfeerate"), Version::ZERO)?,
-            // height_to_minfeerate: StorableVec::forced_import(&path.join("height_to_minfeerate"), Version::ONE)?,
+            // height_to_minfeerate: StorableVec::forced_import(&path.join("height_to_minfeerate"), Version::ZERO)?,
             // height_to_output_count: StorableVec::forced_import(
             //     &path.join("height_to_output_count"),
-            //     Version::ONE,
+            //     Version::ZERO,
             // )?,
-            // height_to_subsidy: StorableVec::forced_import(&path.join("height_to_subsidy"), Version::ONE)?,
+            // height_to_subsidy: StorableVec::forced_import(&path.join("height_to_subsidy"), Version::ZERO)?,
-            // height_to_totalfees: StorableVec::forced_import(&path.join("height_to_totalfees"), Version::ONE)?,
+            // height_to_totalfees: StorableVec::forced_import(&path.join("height_to_totalfees"), Version::ZERO)?,
-            // height_to_txcount: StorableVec::forced_import(&path.join("height_to_txcount"), Version::ONE)?,
+            // height_to_txcount: StorableVec::forced_import(&path.join("height_to_txcount"), Version::ZERO)?,
             // txindex_to_fee: StorableVec::forced_import(
             //     &path.join("txindex_to_fee"),
-            //     Version::ONE,
+            //     Version::ZERO,
             // )?,
-            txindex_to_is_coinbase: StorableVec::forced_import(
+            txindex_to_is_coinbase: ComputedVec::forced_import(
                 &path.join("txindex_to_is_coinbase"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            // txindex_to_feerate: StorableVec::forced_import(&path.join("txindex_to_feerate"), Version::ONE)?,
+            // txindex_to_feerate: StorableVec::forced_import(&path.join("txindex_to_feerate"), Version::ZERO)?,
-            txindex_to_inputs_count: StorableVec::forced_import(
+            txindex_to_input_count: ComputedVecsFromTxindex::forced_import(
-                &path.join("txindex_to_inputs_count"),
+                path,
-                Version::ONE,
+                "input_count",
+                Version::ZERO,
                 compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
             )?,
-            // txindex_to_inputs_sum: StorableVec::forced_import(
+            txindex_to_output_count: ComputedVecsFromTxindex::forced_import(
-            //     &path.join("txindex_to_inputs_sum"),
+                path,
-            //     Version::ONE,
+                "output_count",
-            // )?,
+                Version::ZERO,
-            txindex_to_outputs_count: StorableVec::forced_import(
-                &path.join("txindex_to_outputs_count"),
-                Version::ONE,
                 compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
             )?,
-            // txindex_to_outputs_sum: StorableVec::forced_import(
-            //     &path.join("txindex_to_outputs_sum"),
-            //     Version::ONE,
-            // )?,
             // txinindex_to_value: StorableVec::forced_import(
             //     &path.join("txinindex_to_value"),
-            //     Version::ONE,
+            //     Version::ZERO,
             //     compressed,
             // )?,
         })
@@ -91,22 +91,38 @@ impl Vecs {
         starting_indexes: &Indexes,
         exit: &Exit,
     ) -> color_eyre::Result<()> {
+        self.txindex_to_input_count.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, indexer, indexes, starting_indexes, exit| {
+                v.compute_count_from_indexes(
+                    starting_indexes.txindex,
+                    indexer.mut_vecs().txindex_to_first_txinindex.mut_vec(),
+                    indexes.txindex_to_last_txinindex.mut_vec(),
+                    exit,
+                )
+            },
+        )?;
+
+        self.txindex_to_output_count.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, indexer, indexes, starting_indexes, exit| {
+                v.compute_count_from_indexes(
+                    starting_indexes.txindex,
+                    indexer.mut_vecs().txindex_to_first_txoutindex.mut_vec(),
+                    indexes.txindex_to_last_txoutindex.mut_vec(),
+                    exit,
+                )
+            },
+        )?;
+
         let indexer_vecs = indexer.mut_vecs();
 
-        self.txindex_to_inputs_count.compute_count_from_indexes(
-            starting_indexes.txindex,
-            indexer_vecs.txindex_to_first_txinindex.mut_vec(),
-            indexes.txindex_to_last_txinindex.mut_vec(),
-            exit,
-        )?;
-
-        self.txindex_to_outputs_count.compute_count_from_indexes(
-            starting_indexes.txindex,
-            indexer_vecs.txindex_to_first_txoutindex.mut_vec(),
-            indexes.txindex_to_last_txoutindex.mut_vec(),
-            exit,
-        )?;
-
         self.txindex_to_is_coinbase.compute_is_first_ordered(
             starting_indexes.txindex,
             indexer_vecs.txindex_to_height.mut_vec(),
@@ -135,31 +151,15 @@ impl Vecs {
         //     &mut indexer.vecs().height_to_first_txindex,
         // )?;
 
-        // self.vecs.height_to_dateindex.compute(...)
-
-        // ---
-        // Date to X
-        // ---
-        // ...
-
-        // ---
-        // Month to X
-        // ---
-        // ...
-
-        // ---
-        // Year to X
-        // ---
-        // ...
-
         Ok(())
     }
 
     pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
-        vec![
+        [
-            self.txindex_to_is_coinbase.any_vec(),
+            vec![self.txindex_to_is_coinbase.any_vec()],
-            self.txindex_to_inputs_count.any_vec(),
+            self.txindex_to_output_count.any_vecs(),
-            self.txindex_to_outputs_count.any_vec(),
+            self.txindex_to_input_count.any_vecs(),
         ]
+        .concat()
     }
 }

crates/brk_core/src/structs/mod.rs

@@ -20,6 +20,9 @@ mod monthindex;
 mod ohlc;
 mod quarterindex;
 mod sats;
+mod stored_u32;
+mod stored_u64;
+mod stored_usize;
 mod timestamp;
 mod txid;
 mod txindex;
@@ -55,6 +58,9 @@ pub use monthindex::*;
 pub use ohlc::*;
 pub use quarterindex::*;
 pub use sats::*;
+pub use stored_u32::*;
+pub use stored_u64::*;
+pub use stored_usize::*;
 pub use timestamp::*;
 pub use txid::*;
 pub use txindex::*;

crates/brk_core/src/structs/stored_u32.rs

@@ -0,0 +1,79 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct StoredU32(u32);
+
+impl StoredU32 {
+    pub const ZERO: Self = Self(0);
+
+    pub fn new(counter: u32) -> Self {
+        Self(counter)
+    }
+}
+
+impl From<u32> for StoredU32 {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for StoredU32 {
+    fn from(value: usize) -> Self {
+        Self(value as u32)
+    }
+}
+
+impl CheckedSub<StoredU32> for StoredU32 {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(Self)
+    }
+}
+
+impl Div<usize> for StoredU32 {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self(self.0 / rhs as u32)
+    }
+}
+
+impl Add for StoredU32 {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl From<f64> for StoredU32 {
+    fn from(value: f64) -> Self {
+        if value < 0.0 || value > u32::MAX as f64 {
+            panic!()
+        }
+        Self(value as u32)
+    }
+}
+
+impl From<StoredU32> for f64 {
+    fn from(value: StoredU32) -> Self {
+        value.0 as f64
+    }
+}

crates/brk_core/src/structs/stored_u64.rs

@@ -0,0 +1,93 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+use super::{Txinindex, Txoutindex};
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct StoredU64(u64);
+
+impl StoredU64 {
+    pub const ZERO: Self = Self(0);
+
+    pub fn new(counter: u64) -> Self {
+        Self(counter)
+    }
+}
+
+impl From<u64> for StoredU64 {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for StoredU64 {
+    fn from(value: usize) -> Self {
+        Self(value as u64)
+    }
+}
+
+impl CheckedSub<StoredU64> for StoredU64 {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(Self)
+    }
+}
+
+impl Div<usize> for StoredU64 {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self(self.0 / rhs as u64)
+    }
+}
+
+impl Add for StoredU64 {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl From<f64> for StoredU64 {
+    fn from(value: f64) -> Self {
+        if value < 0.0 || value > u32::MAX as f64 {
+            panic!()
+        }
+        Self(value as u64)
+    }
+}
+
+impl From<StoredU64> for f64 {
+    fn from(value: StoredU64) -> Self {
+        value.0 as f64
+    }
+}
+
+impl From<Txinindex> for StoredU64 {
+    fn from(value: Txinindex) -> Self {
+        Self(*value)
+    }
+}
+
+impl From<Txoutindex> for StoredU64 {
+    fn from(value: Txoutindex) -> Self {
+        Self(*value)
+    }
+}

crates/brk_core/src/structs/stored_usize.rs

@@ -0,0 +1,73 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct StoredUsize(usize);
+
+impl StoredUsize {
+    pub const ZERO: Self = Self(0);
+
+    pub fn new(counter: usize) -> Self {
+        Self(counter)
+    }
+}
+
+impl From<usize> for StoredUsize {
+    fn from(value: usize) -> Self {
+        Self(value)
+    }
+}
+
+impl CheckedSub<StoredUsize> for StoredUsize {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(Self)
+    }
+}
+
+impl Div<usize> for StoredUsize {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self(self.0 / rhs)
+    }
+}
+
+impl Add for StoredUsize {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl From<f64> for StoredUsize {
+    fn from(value: f64) -> Self {
+        if value < 0.0 || value > u32::MAX as f64 {
+            panic!()
+        }
+        Self(value as usize)
+    }
+}
+
+impl From<StoredUsize> for f64 {
+    fn from(value: StoredUsize) -> Self {
+        value.0 as f64
+    }
+}

crates/brk_core/src/structs/weight.rs

@@ -1,8 +1,24 @@
+use std::ops::{Add, Div};
+
 use derive_deref::Deref;
 use serde::Serialize;
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    FromBytes,
+    Serialize,
+)]
 pub struct Weight(u64);
 
 impl From<bitcoin::Weight> for Weight {
@@ -16,3 +32,35 @@ impl From<Weight> for bitcoin::Weight {
         Self::from_wu(*value)
     }
 }
+
+impl From<usize> for Weight {
+    fn from(value: usize) -> Self {
+        Self(value as u64)
+    }
+}
+
+impl From<f64> for Weight {
+    fn from(value: f64) -> Self {
+        Self(value as u64)
+    }
+}
+
+impl From<Weight> for f64 {
+    fn from(value: Weight) -> Self {
+        value.0 as f64
+    }
+}
+
+impl Add for Weight {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Div<usize> for Weight {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self::from(self.0 as usize / rhs)
+    }
+}

crates/brk_indexer/src/indexes.rs

@@ -5,9 +5,10 @@ use brk_core::{
     Pushonlyindex, Txindex, Txinindex, Txoutindex, Unknownindex,
 };
 use brk_parser::NUMBER_OF_UNSAFE_BLOCKS;
+use brk_vec::{Result, StoredIndex, StoredType, Value};
 use color_eyre::eyre::ContextCompat;
 
-use crate::{Stores, Vecs};
+use crate::{IndexedVec, Stores, Vecs};
 
 #[derive(Debug, Default, Clone)]
 pub struct Indexes {
@@ -65,13 +66,7 @@ impl Indexes {
             .push_if_needed(height, self.p2wpkhindex)?;
         vecs.height_to_first_p2wshindex
             .push_if_needed(height, self.p2wshindex)?;
-        Ok(())
-    }
 
-    pub fn push_future_if_needed(&mut self, vecs: &mut Vecs) -> brk_vec::Result<()> {
-        self.height.increment();
-        self.push_if_needed(vecs)?;
-        self.height.decrement();
         Ok(())
     }
 }
@@ -111,32 +106,121 @@ impl TryFrom<(&mut Vecs, &Stores, &Client)> for Indexes {
             .unwrap_or(starting_height);
 
         Ok(Self {
-            addressindex: *vecs.height_to_first_addressindex.get(height)?.context("")?,
+            addressindex: *starting_index(
-            emptyindex: *vecs.height_to_first_emptyindex.get(height)?.context("")?,
+                &vecs.height_to_first_addressindex,
+                &vecs.addressindex_to_height,
+                height,
+            )?
+            .context("")?,
+            emptyindex: *starting_index(
+                &vecs.height_to_first_emptyindex,
+                &vecs.emptyindex_to_height,
+                height,
+            )?
+            .context("")?,
             height,
-            multisigindex: *vecs
+            multisigindex: *starting_index(
-                .height_to_first_multisigindex
+                &vecs.height_to_first_multisigindex,
-                .get(height)?
+                &vecs.multisigindex_to_height,
-                .context("")?,
+                height,
-            opreturnindex: *vecs
+            )?
-                .height_to_first_opreturnindex
+            .context("")?,
-                .get(height)?
+            opreturnindex: *starting_index(
-                .context("")?,
+                &vecs.height_to_first_opreturnindex,
-            p2pk33index: *vecs.height_to_first_p2pk33index.get(height)?.context("")?,
+                &vecs.opreturnindex_to_height,
-            p2pk65index: *vecs.height_to_first_p2pk65index.get(height)?.context("")?,
+                height,
-            p2pkhindex: *vecs.height_to_first_p2pkhindex.get(height)?.context("")?,
+            )?
-            p2shindex: *vecs.height_to_first_p2shindex.get(height)?.context("")?,
+            .context("")?,
-            p2trindex: *vecs.height_to_first_p2trindex.get(height)?.context("")?,
+            p2pk33index: *starting_index(
-            p2wpkhindex: *vecs.height_to_first_p2wpkhindex.get(height)?.context("")?,
+                &vecs.height_to_first_p2pk33index,
-            p2wshindex: *vecs.height_to_first_p2wshindex.get(height)?.context("")?,
+                &vecs.p2pk33index_to_height,
-            pushonlyindex: *vecs
+                height,
-                .height_to_first_pushonlyindex
+            )?
-                .get(height)?
+            .context("")?,
-                .context("")?,
+            p2pk65index: *starting_index(
-            txindex: *vecs.height_to_first_txindex.get(height)?.context("")?,
+                &vecs.height_to_first_p2pk65index,
-            txinindex: *vecs.height_to_first_txinindex.get(height)?.context("")?,
+                &vecs.p2pk65index_to_height,
-            txoutindex: *vecs.height_to_first_txoutindex.get(height)?.context("")?,
+                height,
-            unknownindex: *vecs.height_to_first_unknownindex.get(height)?.context("")?,
+            )?
+            .context("")?,
+            p2pkhindex: *starting_index(
+                &vecs.height_to_first_p2pkhindex,
+                &vecs.p2pkhindex_to_height,
+                height,
+            )?
+            .context("")?,
+            p2shindex: *starting_index(
+                &vecs.height_to_first_p2shindex,
+                &vecs.p2shindex_to_height,
+                height,
+            )?
+            .context("")?,
+            p2trindex: *starting_index(
+                &vecs.height_to_first_p2trindex,
+                &vecs.p2trindex_to_height,
+                height,
+            )?
+            .context("")?,
+            p2wpkhindex: *starting_index(
+                &vecs.height_to_first_p2wpkhindex,
+                &vecs.p2wpkhindex_to_height,
+                height,
+            )?
+            .context("")?,
+            p2wshindex: *starting_index(
+                &vecs.height_to_first_p2wshindex,
+                &vecs.p2wshindex_to_height,
+                height,
+            )?
+            .context("")?,
+            pushonlyindex: *starting_index(
+                &vecs.height_to_first_pushonlyindex,
+                &vecs.pushonlyindex_to_height,
+                height,
+            )?
+            .context("")?,
+            txindex: *starting_index(
+                &vecs.height_to_first_txindex,
+                &vecs.txindex_to_height,
+                height,
+            )?
+            .context("")?,
+            txinindex: *starting_index(
+                &vecs.height_to_first_txinindex,
+                &vecs.txinindex_to_height,
+                height,
+            )?
+            .context("")?,
+            txoutindex: *starting_index(
+                &vecs.height_to_first_txoutindex,
+                &vecs.txoutindex_to_height,
+                height,
+            )?
+            .context("")?,
+            unknownindex: *starting_index(
+                &vecs.height_to_first_unknownindex,
+                &vecs.unknownindex_to_height,
+                height,
+            )?
+            .context("")?,
         })
     }
 }
+
+pub fn starting_index<'a, I>(
+    height_to_index: &'a IndexedVec<Height, I>,
+    index_to_height: &'a IndexedVec<I, Height>,
+    starting_height: Height,
+) -> Result<Option<Value<'a, I>>>
+where
+    I: StoredType + StoredIndex + From<usize>,
+{
+    if height_to_index
+        .height()
+        .is_ok_and(|h| h + 1_u32 == starting_height)
+    {
+        Ok(Some(Value::Owned(I::from(index_to_height.len()))))
+    } else {
+        height_to_index.get(starting_height)
+    }
+}

crates/brk_indexer/src/lib.rs

@@ -31,7 +31,7 @@ pub use stores::*;
 pub use vecs::*;
 
 const SNAPSHOT_BLOCK_RANGE: usize = 1000;
-const COLLISIONS_CHECKED_UP_TO: u32 = 888_000;
+const COLLISIONS_CHECKED_UP_TO: u32 = 890_000;
 
 #[derive(Clone)]
 pub struct Indexer {
@@ -101,6 +101,7 @@ impl Indexer {
         let vecs = self.vecs.as_mut().unwrap();
         let stores = self.stores.as_mut().unwrap();
 
+        // Cloned because we want to return starting indexes for the computer
         let mut idxs = starting_indexes.clone();
 
         let start = Some(idxs.height);
@@ -153,6 +154,8 @@ impl Indexer {
                     return Err(eyre!("Collision, expect prefix to need be set yet"));
                 }
 
+                idxs.push_if_needed(vecs)?;
+
                 stores
                     .blockhash_prefix_to_height
                     .insert_if_needed(blockhash_prefix, height, height);
@@ -162,8 +165,8 @@ impl Indexer {
                     .push_if_needed(height, block.header.difficulty_float())?;
                 vecs.height_to_timestamp
                     .push_if_needed(height, Timestamp::from(block.header.time))?;
-                vecs.height_to_size.push_if_needed(height, block.total_size())?;
+                vecs.height_to_block_size.push_if_needed(height, block.total_size().into())?;
-                vecs.height_to_weight.push_if_needed(height, block.weight().into())?;
+                vecs.height_to_block_weight.push_if_needed(height, block.weight().into())?;
 
                 let inputs = block
                     .txdata
@@ -462,6 +465,9 @@ impl Indexer {
 
                         vecs.txoutindex_to_value.push_if_needed(txoutindex, sats)?;
 
+                        vecs.txoutindex_to_height
+                            .push_if_needed(txoutindex, height)?;
+
                         let mut addressindex = idxs.addressindex;
 
                         let mut addresshash = None;
@@ -481,18 +487,55 @@ impl Indexer {
                             idxs.addressindex.increment();
 
                             let addresstypeindex = match addresstype {
-                                Addresstype::Empty => idxs.emptyindex.copy_then_increment(),
+                                Addresstype::Empty => {
-                                Addresstype::Multisig => idxs.multisigindex.copy_then_increment(),
+                                    vecs.emptyindex_to_height
-                                Addresstype::OpReturn => idxs.opreturnindex.copy_then_increment(),
+                                        .push_if_needed(idxs.emptyindex, height)?;
-                                Addresstype::PushOnly => idxs.pushonlyindex.copy_then_increment(),
+                                    idxs.emptyindex.copy_then_increment()
-                                Addresstype::Unknown => idxs.unknownindex.copy_then_increment(),
+                                },
-                                Addresstype::P2PK65 => idxs.p2pk65index.copy_then_increment(),
+                                Addresstype::Multisig => {
-                                Addresstype::P2PK33 => idxs.p2pk33index.copy_then_increment(),
+                                    vecs.multisigindex_to_height.push_if_needed(idxs.multisigindex, height)?;
-                                Addresstype::P2PKH => idxs.p2pkhindex.copy_then_increment(),
+                                    idxs.multisigindex.copy_then_increment()
-                                Addresstype::P2SH => idxs.p2shindex.copy_then_increment(),
+                                },
-                                Addresstype::P2WPKH => idxs.p2wpkhindex.copy_then_increment(),
+                                Addresstype::OpReturn => {
-                                Addresstype::P2WSH => idxs.p2wshindex.copy_then_increment(),
+                                    vecs.opreturnindex_to_height.push_if_needed(idxs.opreturnindex, height)?;
-                                Addresstype::P2TR => idxs.p2trindex.copy_then_increment(),
+                                    idxs.opreturnindex.copy_then_increment()
+                                },
+                                Addresstype::PushOnly => {
+                                    vecs.pushonlyindex_to_height.push_if_needed(idxs.pushonlyindex, height)?;
+                                    idxs.pushonlyindex.copy_then_increment()
+                                },
+                                Addresstype::Unknown => {
+                                    vecs.unknownindex_to_height.push_if_needed(idxs.unknownindex, height)?;
+                                    idxs.unknownindex.copy_then_increment()
+                                },
+                                Addresstype::P2PK65 => {
+                                    vecs.p2pk65index_to_height.push_if_needed(idxs.p2pk65index, height)?;
+                                    idxs.p2pk65index.copy_then_increment()
+                                },
+                                Addresstype::P2PK33 => {
+                                    vecs.p2pk33index_to_height.push_if_needed(idxs.p2pk33index, height)?;
+                                    idxs.p2pk33index.copy_then_increment()
+                                },
+                                Addresstype::P2PKH => {
+                                    vecs.p2pkhindex_to_height.push_if_needed(idxs.p2pkhindex, height)?;
+                                    idxs.p2pkhindex.copy_then_increment()
+                                },
+                                Addresstype::P2SH => {
+                                    vecs.p2shindex_to_height.push_if_needed(idxs.p2shindex, height)?;
+                                    idxs.p2shindex.copy_then_increment()
+                                },
+                                Addresstype::P2WPKH => {
+                                    vecs.p2wpkhindex_to_height.push_if_needed(idxs.p2wpkhindex, height)?;
+                                    idxs.p2wpkhindex.copy_then_increment()
+                                },
+                                Addresstype::P2WSH => {
+                                    vecs.p2wshindex_to_height.push_if_needed(idxs.p2wshindex, height)?;
+                                    idxs.p2wshindex.copy_then_increment()
+                                },
+                                Addresstype::P2TR => {
+                                    vecs.p2trindex_to_height.push_if_needed(idxs.p2trindex, height)?;
+                                    idxs.p2trindex.copy_then_increment()
+                                },
                             };
 
                             vecs.addressindex_to_addresstype
@@ -580,6 +623,10 @@ impl Indexer {
 
                         vecs.txinindex_to_txoutindex.push_if_needed(txinindex, txoutindex)?;
 
+                        vecs.txinindex_to_height
+                            .push_if_needed(txinindex, height)?;
+
+
                         Ok(())
                     })?;
 
@@ -668,8 +715,6 @@ impl Indexer {
                 idxs.txinindex += Txinindex::from(inputs_len);
                 idxs.txoutindex += Txoutindex::from(outputs_len);
 
-                idxs.push_future_if_needed(vecs)?;
-
                 export_if_needed(stores, vecs, height, false, exit)?;
 
                 Ok(())

crates/brk_indexer/src/stores/mod.rs

@@ -27,11 +27,11 @@ impl Stores {
     pub fn import(path: &Path) -> color_eyre::Result<Self> {
         thread::scope(|scope| {
             let addresshash_to_addressindex = scope
-                .spawn(|| Store::import(&path.join("addresshash_to_addressindex"), Version::ONE));
+                .spawn(|| Store::import(&path.join("addresshash_to_addressindex"), Version::ZERO));
             let blockhash_prefix_to_height = scope
-                .spawn(|| Store::import(&path.join("blockhash_prefix_to_height"), Version::ONE));
+                .spawn(|| Store::import(&path.join("blockhash_prefix_to_height"), Version::ZERO));
             let txid_prefix_to_txindex =
-                scope.spawn(|| Store::import(&path.join("txid_prefix_to_txindex"), Version::ONE));
+                scope.spawn(|| Store::import(&path.join("txid_prefix_to_txindex"), Version::ZERO));
 
             Ok(Self {
                 addresshash_to_addressindex: addresshash_to_addressindex.join().unwrap()?,

crates/brk_indexer/src/vecs/base.rs

@@ -6,19 +6,19 @@ use std::{
 };
 
 use brk_vec::{
-    AnyStorableVec, Compressed, Error, MAX_CACHE_SIZE, MAX_PAGE_SIZE, Result, StoredIndex,
+    AnyStorableVec, Compressed, Error, MAX_CACHE_SIZE, MAX_PAGE_SIZE, Result, StorableVec,
-    StoredType, Value, Version,
+    StoredIndex, StoredType, Value, Version,
 };
 
 use super::Height;
 
 #[derive(Debug)]
-pub struct StorableVec<I, T> {
+pub struct IndexedVec<I, T> {
     height: Option<Height>,
-    vec: brk_vec::StorableVec<I, T>,
+    vec: StorableVec<I, T>,
 }
 
-impl<I, T> StorableVec<I, T>
+impl<I, T> IndexedVec<I, T>
 where
     I: StoredIndex,
     T: StoredType,
@@ -33,7 +33,7 @@ where
         version: Version,
         compressed: Compressed,
     ) -> brk_vec::Result<Self> {
-        let mut vec = brk_vec::StorableVec::forced_import(path, version, compressed)?;
+        let mut vec = StorableVec::forced_import(path, version, compressed)?;
 
         vec.enable_large_cache();
 
@@ -107,7 +107,7 @@ where
                 Ok(())
             }
             Ordering::Less => {
-                dbg!(index, value);
+                dbg!(index, value, self.vec.len(), self.path_height());
                 Err(Error::IndexTooHigh)
             }
         }
@@ -126,11 +126,11 @@ where
         self.vec.flush()
     }
 
-    pub fn vec(&self) -> &brk_vec::StorableVec<I, T> {
+    pub fn vec(&self) -> &StorableVec<I, T> {
         &self.vec
     }
 
-    pub fn mut_vec(&mut self) -> &mut brk_vec::StorableVec<I, T> {
+    pub fn mut_vec(&mut self) -> &mut StorableVec<I, T> {
         &mut self.vec
     }
 
@@ -162,7 +162,7 @@ where
     }
 }
 
-impl<I, T> Clone for StorableVec<I, T>
+impl<I, T> Clone for IndexedVec<I, T>
 where
     I: StoredIndex,
     T: StoredType,
@@ -180,7 +180,7 @@ pub trait AnyIndexedVec: Send + Sync {
     fn flush(&mut self, height: Height) -> io::Result<()>;
 }
 
-impl<I, T> AnyIndexedVec for StorableVec<I, T>
+impl<I, T> AnyIndexedVec for IndexedVec<I, T>
 where
     I: StoredIndex,
     T: StoredType,

crates/brk_indexer/src/vecs/mod.rs

@@ -5,7 +5,7 @@ use brk_core::{
     LockTime, Multisigindex, Opreturnindex, P2PK33AddressBytes, P2PK33index, P2PK65AddressBytes,
     P2PK65index, P2PKHAddressBytes, P2PKHindex, P2SHAddressBytes, P2SHindex, P2TRAddressBytes,
     P2TRindex, P2WPKHAddressBytes, P2WPKHindex, P2WSHAddressBytes, P2WSHindex, Pushonlyindex, Sats,
-    Timestamp, TxVersion, Txid, Txindex, Txinindex, Txoutindex, Unknownindex, Weight,
+    StoredUsize, Timestamp, TxVersion, Txid, Txindex, Txinindex, Txoutindex, Unknownindex, Weight,
 };
 use brk_vec::{AnyStorableVec, Compressed, Version};
 use rayon::prelude::*;
@@ -18,50 +18,64 @@ pub use base::*;
 
 #[derive(Clone)]
 pub struct Vecs {
-    pub addressindex_to_addresstype: StorableVec<Addressindex, Addresstype>,
+    pub addressindex_to_addresstype: IndexedVec<Addressindex, Addresstype>,
-    pub addressindex_to_addresstypeindex: StorableVec<Addressindex, Addresstypeindex>,
+    pub addressindex_to_addresstypeindex: IndexedVec<Addressindex, Addresstypeindex>,
-    pub addressindex_to_height: StorableVec<Addressindex, Height>,
+    pub addressindex_to_height: IndexedVec<Addressindex, Height>,
-    pub height_to_blockhash: StorableVec<Height, BlockHash>,
+    pub emptyindex_to_height: IndexedVec<Emptyindex, Height>,
-    pub height_to_difficulty: StorableVec<Height, f64>,
+    pub height_to_blockhash: IndexedVec<Height, BlockHash>,
-    pub height_to_first_addressindex: StorableVec<Height, Addressindex>,
+    pub height_to_difficulty: IndexedVec<Height, f64>,
-    pub height_to_first_emptyindex: StorableVec<Height, Emptyindex>,
+    pub height_to_first_addressindex: IndexedVec<Height, Addressindex>,
-    pub height_to_first_multisigindex: StorableVec<Height, Multisigindex>,
+    pub height_to_first_emptyindex: IndexedVec<Height, Emptyindex>,
-    pub height_to_first_opreturnindex: StorableVec<Height, Opreturnindex>,
+    pub height_to_first_multisigindex: IndexedVec<Height, Multisigindex>,
-    pub height_to_first_pushonlyindex: StorableVec<Height, Pushonlyindex>,
+    pub height_to_first_opreturnindex: IndexedVec<Height, Opreturnindex>,
-    pub height_to_first_txindex: StorableVec<Height, Txindex>,
+    pub height_to_first_p2pk33index: IndexedVec<Height, P2PK33index>,
-    pub height_to_first_txinindex: StorableVec<Height, Txinindex>,
+    pub height_to_first_p2pk65index: IndexedVec<Height, P2PK65index>,
-    pub height_to_first_txoutindex: StorableVec<Height, Txoutindex>,
+    pub height_to_first_p2pkhindex: IndexedVec<Height, P2PKHindex>,
-    pub height_to_first_unknownindex: StorableVec<Height, Unknownindex>,
+    pub height_to_first_p2shindex: IndexedVec<Height, P2SHindex>,
-    pub height_to_first_p2pk33index: StorableVec<Height, P2PK33index>,
+    pub height_to_first_p2trindex: IndexedVec<Height, P2TRindex>,
-    pub height_to_first_p2pk65index: StorableVec<Height, P2PK65index>,
+    pub height_to_first_p2wpkhindex: IndexedVec<Height, P2WPKHindex>,
-    pub height_to_first_p2pkhindex: StorableVec<Height, P2PKHindex>,
+    pub height_to_first_p2wshindex: IndexedVec<Height, P2WSHindex>,
-    pub height_to_first_p2shindex: StorableVec<Height, P2SHindex>,
+    pub height_to_first_pushonlyindex: IndexedVec<Height, Pushonlyindex>,
-    pub height_to_first_p2trindex: StorableVec<Height, P2TRindex>,
+    pub height_to_first_txindex: IndexedVec<Height, Txindex>,
-    pub height_to_first_p2wpkhindex: StorableVec<Height, P2WPKHindex>,
+    pub height_to_first_txinindex: IndexedVec<Height, Txinindex>,
-    pub height_to_first_p2wshindex: StorableVec<Height, P2WSHindex>,
+    pub height_to_first_txoutindex: IndexedVec<Height, Txoutindex>,
-    pub height_to_size: StorableVec<Height, usize>,
+    pub height_to_first_unknownindex: IndexedVec<Height, Unknownindex>,
-    pub height_to_timestamp: StorableVec<Height, Timestamp>,
+    pub height_to_block_size: IndexedVec<Height, StoredUsize>,
-    pub height_to_weight: StorableVec<Height, Weight>,
+    pub height_to_timestamp: IndexedVec<Height, Timestamp>,
-    pub p2pk33index_to_p2pk33addressbytes: StorableVec<P2PK33index, P2PK33AddressBytes>,
+    pub height_to_block_weight: IndexedVec<Height, Weight>,
-    pub p2pk65index_to_p2pk65addressbytes: StorableVec<P2PK65index, P2PK65AddressBytes>,
+    pub multisigindex_to_height: IndexedVec<Multisigindex, Height>,
-    pub p2pkhindex_to_p2pkhaddressbytes: StorableVec<P2PKHindex, P2PKHAddressBytes>,
+    pub opreturnindex_to_height: IndexedVec<Opreturnindex, Height>,
-    pub p2shindex_to_p2shaddressbytes: StorableVec<P2SHindex, P2SHAddressBytes>,
+    pub p2pk33index_to_height: IndexedVec<P2PK33index, Height>,
-    pub p2trindex_to_p2traddressbytes: StorableVec<P2TRindex, P2TRAddressBytes>,
+    pub p2pk33index_to_p2pk33addressbytes: IndexedVec<P2PK33index, P2PK33AddressBytes>,
-    pub p2wpkhindex_to_p2wpkhaddressbytes: StorableVec<P2WPKHindex, P2WPKHAddressBytes>,
+    pub p2pk65index_to_height: IndexedVec<P2PK65index, Height>,
-    pub p2wshindex_to_p2wshaddressbytes: StorableVec<P2WSHindex, P2WSHAddressBytes>,
+    pub p2pk65index_to_p2pk65addressbytes: IndexedVec<P2PK65index, P2PK65AddressBytes>,
-    pub txindex_to_first_txinindex: StorableVec<Txindex, Txinindex>,
+    pub p2pkhindex_to_height: IndexedVec<P2PKHindex, Height>,
-    pub txindex_to_first_txoutindex: StorableVec<Txindex, Txoutindex>,
+    pub p2pkhindex_to_p2pkhaddressbytes: IndexedVec<P2PKHindex, P2PKHAddressBytes>,
-    pub txindex_to_height: StorableVec<Txindex, Height>,
+    pub p2shindex_to_height: IndexedVec<P2SHindex, Height>,
-    pub txindex_to_locktime: StorableVec<Txindex, LockTime>,
+    pub p2shindex_to_p2shaddressbytes: IndexedVec<P2SHindex, P2SHAddressBytes>,
-    pub txindex_to_txid: StorableVec<Txindex, Txid>,
+    pub p2trindex_to_height: IndexedVec<P2TRindex, Height>,
-    pub txindex_to_base_size: StorableVec<Txindex, usize>,
+    pub p2trindex_to_p2traddressbytes: IndexedVec<P2TRindex, P2TRAddressBytes>,
-    pub txindex_to_total_size: StorableVec<Txindex, usize>,
+    pub p2wpkhindex_to_height: IndexedVec<P2WPKHindex, Height>,
-    pub txindex_to_is_explicitly_rbf: StorableVec<Txindex, bool>,
+    pub p2wpkhindex_to_p2wpkhaddressbytes: IndexedVec<P2WPKHindex, P2WPKHAddressBytes>,
-    pub txindex_to_txversion: StorableVec<Txindex, TxVersion>,
+    pub p2wshindex_to_height: IndexedVec<P2WSHindex, Height>,
+    pub p2wshindex_to_p2wshaddressbytes: IndexedVec<P2WSHindex, P2WSHAddressBytes>,
+    pub pushonlyindex_to_height: IndexedVec<Pushonlyindex, Height>,
+    pub txindex_to_base_size: IndexedVec<Txindex, usize>,
+    pub txindex_to_first_txinindex: IndexedVec<Txindex, Txinindex>,
+    pub txindex_to_first_txoutindex: IndexedVec<Txindex, Txoutindex>,
+    pub txindex_to_height: IndexedVec<Txindex, Height>,
+    pub txindex_to_is_explicitly_rbf: IndexedVec<Txindex, bool>,
+    pub txindex_to_locktime: IndexedVec<Txindex, LockTime>,
+    pub txindex_to_total_size: IndexedVec<Txindex, usize>,
+    pub txindex_to_txid: IndexedVec<Txindex, Txid>,
+    pub txindex_to_txversion: IndexedVec<Txindex, TxVersion>,
+    pub txinindex_to_height: IndexedVec<Txinindex, Height>,
     /// If txoutindex == Txoutindex MAX then is it's coinbase
-    pub txinindex_to_txoutindex: StorableVec<Txinindex, Txoutindex>,
+    pub txinindex_to_txoutindex: IndexedVec<Txinindex, Txoutindex>,
-    pub txoutindex_to_addressindex: StorableVec<Txoutindex, Addressindex>,
+    pub txoutindex_to_addressindex: IndexedVec<Txoutindex, Addressindex>,
-    pub txoutindex_to_value: StorableVec<Txoutindex, Sats>,
+    pub txoutindex_to_height: IndexedVec<Txoutindex, Height>,
+    pub txoutindex_to_value: IndexedVec<Txoutindex, Sats>,
+    pub unknownindex_to_height: IndexedVec<Unknownindex, Height>,
 }
 
 impl Vecs {
@@ -69,219 +83,289 @@ impl Vecs {
         fs::create_dir_all(path)?;
 
         Ok(Self {
-            addressindex_to_addresstype: StorableVec::forced_import(
+            addressindex_to_addresstype: IndexedVec::forced_import(
                 &path.join("addressindex_to_addresstype"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            addressindex_to_addresstypeindex: StorableVec::forced_import(
+            addressindex_to_addresstypeindex: IndexedVec::forced_import(
                 &path.join("addressindex_to_addresstypeindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            addressindex_to_height: StorableVec::forced_import(
+            addressindex_to_height: IndexedVec::forced_import(
                 &path.join("addressindex_to_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_blockhash: StorableVec::forced_import(
+            height_to_blockhash: IndexedVec::forced_import(
                 &path.join("height_to_blockhash"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            height_to_difficulty: StorableVec::forced_import(
+            height_to_difficulty: IndexedVec::forced_import(
                 &path.join("height_to_difficulty"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_addressindex: StorableVec::forced_import(
+            height_to_first_addressindex: IndexedVec::forced_import(
                 &path.join("height_to_first_addressindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_emptyindex: StorableVec::forced_import(
+            height_to_first_emptyindex: IndexedVec::forced_import(
                 &path.join("height_to_first_emptyindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_multisigindex: StorableVec::forced_import(
+            height_to_first_multisigindex: IndexedVec::forced_import(
                 &path.join("height_to_first_multisigindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_opreturnindex: StorableVec::forced_import(
+            height_to_first_opreturnindex: IndexedVec::forced_import(
                 &path.join("height_to_first_opreturnindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_pushonlyindex: StorableVec::forced_import(
+            height_to_first_pushonlyindex: IndexedVec::forced_import(
                 &path.join("height_to_first_pushonlyindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_txindex: StorableVec::forced_import(
+            height_to_first_txindex: IndexedVec::forced_import(
                 &path.join("height_to_first_txindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_txinindex: StorableVec::forced_import(
+            height_to_first_txinindex: IndexedVec::forced_import(
                 &path.join("height_to_first_txinindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_txoutindex: StorableVec::forced_import(
+            height_to_first_txoutindex: IndexedVec::forced_import(
                 &path.join("height_to_first_txoutindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_unknownindex: StorableVec::forced_import(
+            height_to_first_unknownindex: IndexedVec::forced_import(
                 &path.join("height_to_first_unkownindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_p2pk33index: StorableVec::forced_import(
+            height_to_first_p2pk33index: IndexedVec::forced_import(
                 &path.join("height_to_first_p2pk33index"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_p2pk65index: StorableVec::forced_import(
+            height_to_first_p2pk65index: IndexedVec::forced_import(
                 &path.join("height_to_first_p2pk65index"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_p2pkhindex: StorableVec::forced_import(
+            height_to_first_p2pkhindex: IndexedVec::forced_import(
                 &path.join("height_to_first_p2pkhindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_p2shindex: StorableVec::forced_import(
+            height_to_first_p2shindex: IndexedVec::forced_import(
                 &path.join("height_to_first_p2shindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_p2trindex: StorableVec::forced_import(
+            height_to_first_p2trindex: IndexedVec::forced_import(
                 &path.join("height_to_first_p2trindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_p2wpkhindex: StorableVec::forced_import(
+            height_to_first_p2wpkhindex: IndexedVec::forced_import(
                 &path.join("height_to_first_p2wpkhindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_first_p2wshindex: StorableVec::forced_import(
+            height_to_first_p2wshindex: IndexedVec::forced_import(
                 &path.join("height_to_first_p2wshindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_size: StorableVec::forced_import(
+            height_to_block_size: IndexedVec::forced_import(
-                &path.join("height_to_size"),
+                &path.join("height_to_block_size"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_timestamp: StorableVec::forced_import(
+            height_to_timestamp: IndexedVec::forced_import(
                 &path.join("height_to_timestamp"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            height_to_weight: StorableVec::forced_import(
+            height_to_block_weight: IndexedVec::forced_import(
-                &path.join("height_to_weight"),
+                &path.join("height_to_block_weight"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            p2pk33index_to_p2pk33addressbytes: StorableVec::forced_import(
+            p2pk33index_to_p2pk33addressbytes: IndexedVec::forced_import(
                 &path.join("p2pk33index_to_p2pk33addressbytes"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            p2pk65index_to_p2pk65addressbytes: StorableVec::forced_import(
+            p2pk65index_to_p2pk65addressbytes: IndexedVec::forced_import(
                 &path.join("p2pk65index_to_p2pk65addressbytes"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            p2pkhindex_to_p2pkhaddressbytes: StorableVec::forced_import(
+            p2pkhindex_to_p2pkhaddressbytes: IndexedVec::forced_import(
                 &path.join("p2pkhindex_to_p2pkhaddressbytes"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            p2shindex_to_p2shaddressbytes: StorableVec::forced_import(
+            p2shindex_to_p2shaddressbytes: IndexedVec::forced_import(
                 &path.join("p2shindex_to_p2shaddressbytes"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            p2trindex_to_p2traddressbytes: StorableVec::forced_import(
+            p2trindex_to_p2traddressbytes: IndexedVec::forced_import(
                 &path.join("p2trindex_to_p2traddressbytes"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            p2wpkhindex_to_p2wpkhaddressbytes: StorableVec::forced_import(
+            p2wpkhindex_to_p2wpkhaddressbytes: IndexedVec::forced_import(
                 &path.join("p2wpkhindex_to_p2wpkhaddressbytes"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            p2wshindex_to_p2wshaddressbytes: StorableVec::forced_import(
+            p2wshindex_to_p2wshaddressbytes: IndexedVec::forced_import(
                 &path.join("p2wshindex_to_p2wshaddressbytes"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            txindex_to_first_txinindex: StorableVec::forced_import(
+            txindex_to_first_txinindex: IndexedVec::forced_import(
                 &path.join("txindex_to_first_txinindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_first_txoutindex: StorableVec::forced_import(
+            txindex_to_first_txoutindex: IndexedVec::forced_import(
                 &path.join("txindex_to_first_txoutindex"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            txindex_to_height: StorableVec::forced_import(
+            txindex_to_height: IndexedVec::forced_import(
                 &path.join("txindex_to_height"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_locktime: StorableVec::forced_import(
+            txindex_to_locktime: IndexedVec::forced_import(
                 &path.join("txindex_to_locktime"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_txid: StorableVec::forced_import(
+            txindex_to_txid: IndexedVec::forced_import(
                 &path.join("txindex_to_txid"),
-                Version::ONE,
+                Version::ZERO,
                 Compressed::NO,
             )?,
-            txindex_to_base_size: StorableVec::forced_import(
+            txindex_to_base_size: IndexedVec::forced_import(
                 &path.join("txindex_to_base_size"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_total_size: StorableVec::forced_import(
+            txindex_to_total_size: IndexedVec::forced_import(
                 &path.join("txindex_to_total_size"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_is_explicitly_rbf: StorableVec::forced_import(
+            txindex_to_is_explicitly_rbf: IndexedVec::forced_import(
                 &path.join("txindex_to_is_explicitly_rbf"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txindex_to_txversion: StorableVec::forced_import(
+            txindex_to_txversion: IndexedVec::forced_import(
                 &path.join("txindex_to_txversion"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txinindex_to_txoutindex: StorableVec::forced_import(
+            txinindex_to_txoutindex: IndexedVec::forced_import(
                 &path.join("txinindex_to_txoutindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txoutindex_to_addressindex: StorableVec::forced_import(
+            txoutindex_to_addressindex: IndexedVec::forced_import(
                 &path.join("txoutindex_to_addressindex"),
-                Version::ONE,
+                Version::ZERO,
                 compressed,
             )?,
-            txoutindex_to_value: StorableVec::forced_import(
+            txoutindex_to_value: IndexedVec::forced_import(
                 &path.join("txoutindex_to_value"),
-                Version::ONE,
+                Version::ZERO,
+                compressed,
+            )?,
+            emptyindex_to_height: IndexedVec::forced_import(
+                &path.join("emptyindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            multisigindex_to_height: IndexedVec::forced_import(
+                &path.join("multisigindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            opreturnindex_to_height: IndexedVec::forced_import(
+                &path.join("opreturnindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            pushonlyindex_to_height: IndexedVec::forced_import(
+                &path.join("pushonlyindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            txinindex_to_height: IndexedVec::forced_import(
+                &path.join("txinindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            txoutindex_to_height: IndexedVec::forced_import(
+                &path.join("txoutindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            unknownindex_to_height: IndexedVec::forced_import(
+                &path.join("unknownindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2pk33index_to_height: IndexedVec::forced_import(
+                &path.join("p2pk33index_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2pk65index_to_height: IndexedVec::forced_import(
+                &path.join("p2pk65index_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2pkhindex_to_height: IndexedVec::forced_import(
+                &path.join("p2pkhindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2shindex_to_height: IndexedVec::forced_import(
+                &path.join("p2shindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2trindex_to_height: IndexedVec::forced_import(
+                &path.join("p2trindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2wpkhindex_to_height: IndexedVec::forced_import(
+                &path.join("p2wpkhindex_to_height"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2wshindex_to_height: IndexedVec::forced_import(
+                &path.join("p2wshindex_to_height"),
+                Version::ZERO,
                 compressed,
             )?,
         })
@@ -290,8 +374,26 @@ impl Vecs {
     pub fn rollback_if_needed(&mut self, starting_indexes: &Indexes) -> brk_vec::Result<()> {
         let saved_height = starting_indexes.height.decremented().unwrap_or_default();
 
-        // We don't want to override the starting indexes so we cut from n + 1
+        // Now we can cut everything that's out of date
-        let height = starting_indexes.height.incremented();
+        let &Indexes {
+            addressindex,
+            height,
+            p2pk33index,
+            p2pk65index,
+            p2pkhindex,
+            p2shindex,
+            p2trindex,
+            p2wpkhindex,
+            p2wshindex,
+            txindex,
+            txinindex,
+            txoutindex,
+            unknownindex,
+            pushonlyindex,
+            opreturnindex,
+            multisigindex,
+            emptyindex,
+        } = starting_indexes;
 
         self.height_to_first_addressindex
             .truncate_if_needed(height, saved_height)?;
@@ -326,32 +428,15 @@ impl Vecs {
         self.height_to_first_unknownindex
             .truncate_if_needed(height, saved_height)?;
 
-        // Now we can cut everything that's out of date
-        let &Indexes {
-            addressindex,
-            height,
-            p2pk33index,
-            p2pk65index,
-            p2pkhindex,
-            p2shindex,
-            p2trindex,
-            p2wpkhindex,
-            p2wshindex,
-            txindex,
-            txinindex,
-            txoutindex,
-            ..
-        } = starting_indexes;
-
         self.height_to_blockhash
             .truncate_if_needed(height, saved_height)?;
         self.height_to_difficulty
             .truncate_if_needed(height, saved_height)?;
-        self.height_to_size
+        self.height_to_block_size
             .truncate_if_needed(height, saved_height)?;
         self.height_to_timestamp
             .truncate_if_needed(height, saved_height)?;
-        self.height_to_weight
+        self.height_to_block_weight
             .truncate_if_needed(height, saved_height)?;
 
         self.addressindex_to_addresstype
@@ -403,6 +488,35 @@ impl Vecs {
         self.txoutindex_to_value
             .truncate_if_needed(txoutindex, saved_height)?;
 
+        self.emptyindex_to_height
+            .truncate_if_needed(emptyindex, saved_height)?;
+        self.multisigindex_to_height
+            .truncate_if_needed(multisigindex, saved_height)?;
+        self.opreturnindex_to_height
+            .truncate_if_needed(opreturnindex, saved_height)?;
+        self.pushonlyindex_to_height
+            .truncate_if_needed(pushonlyindex, saved_height)?;
+        self.txinindex_to_height
+            .truncate_if_needed(txinindex, saved_height)?;
+        self.txoutindex_to_height
+            .truncate_if_needed(txoutindex, saved_height)?;
+        self.unknownindex_to_height
+            .truncate_if_needed(unknownindex, saved_height)?;
+        self.p2pk33index_to_height
+            .truncate_if_needed(p2pk33index, saved_height)?;
+        self.p2pk65index_to_height
+            .truncate_if_needed(p2pk65index, saved_height)?;
+        self.p2pkhindex_to_height
+            .truncate_if_needed(p2pkhindex, saved_height)?;
+        self.p2shindex_to_height
+            .truncate_if_needed(p2shindex, saved_height)?;
+        self.p2trindex_to_height
+            .truncate_if_needed(p2trindex, saved_height)?;
+        self.p2wpkhindex_to_height
+            .truncate_if_needed(p2wpkhindex, saved_height)?;
+        self.p2wshindex_to_height
+            .truncate_if_needed(p2wshindex, saved_height)?;
+
         Ok(())
     }
 
@@ -518,9 +632,9 @@ impl Vecs {
             self.height_to_first_p2trindex.any_vec(),
             self.height_to_first_p2wpkhindex.any_vec(),
             self.height_to_first_p2wshindex.any_vec(),
-            self.height_to_size.any_vec(),
+            self.height_to_block_size.any_vec(),
             self.height_to_timestamp.any_vec(),
-            self.height_to_weight.any_vec(),
+            self.height_to_block_weight.any_vec(),
             self.p2pk33index_to_p2pk33addressbytes.any_vec(),
             self.p2pk65index_to_p2pk65addressbytes.any_vec(),
             self.p2pkhindex_to_p2pkhaddressbytes.any_vec(),
@@ -540,6 +654,20 @@ impl Vecs {
             self.txinindex_to_txoutindex.any_vec(),
             self.txoutindex_to_addressindex.any_vec(),
             self.txoutindex_to_value.any_vec(),
+            self.emptyindex_to_height.any_vec(),
+            self.multisigindex_to_height.any_vec(),
+            self.opreturnindex_to_height.any_vec(),
+            self.pushonlyindex_to_height.any_vec(),
+            self.txinindex_to_height.any_vec(),
+            self.txoutindex_to_height.any_vec(),
+            self.unknownindex_to_height.any_vec(),
+            self.p2pk33index_to_height.any_vec(),
+            self.p2pk65index_to_height.any_vec(),
+            self.p2pkhindex_to_height.any_vec(),
+            self.p2shindex_to_height.any_vec(),
+            self.p2trindex_to_height.any_vec(),
+            self.p2wpkhindex_to_height.any_vec(),
+            self.p2wshindex_to_height.any_vec(),
         ]
     }
 
@@ -566,9 +694,9 @@ impl Vecs {
             &mut self.height_to_first_p2trindex,
             &mut self.height_to_first_p2wpkhindex,
             &mut self.height_to_first_p2wshindex,
-            &mut self.height_to_size,
+            &mut self.height_to_block_size,
             &mut self.height_to_timestamp,
-            &mut self.height_to_weight,
+            &mut self.height_to_block_weight,
             &mut self.p2pk33index_to_p2pk33addressbytes,
             &mut self.p2pk65index_to_p2pk65addressbytes,
             &mut self.p2pkhindex_to_p2pkhaddressbytes,
@@ -588,6 +716,20 @@ impl Vecs {
             &mut self.txinindex_to_txoutindex,
             &mut self.txoutindex_to_addressindex,
             &mut self.txoutindex_to_value,
+            &mut self.emptyindex_to_height,
+            &mut self.multisigindex_to_height,
+            &mut self.opreturnindex_to_height,
+            &mut self.pushonlyindex_to_height,
+            &mut self.txinindex_to_height,
+            &mut self.txoutindex_to_height,
+            &mut self.unknownindex_to_height,
+            &mut self.p2pk33index_to_height,
+            &mut self.p2pk65index_to_height,
+            &mut self.p2pkhindex_to_height,
+            &mut self.p2shindex_to_height,
+            &mut self.p2trindex_to_height,
+            &mut self.p2wpkhindex_to_height,
+            &mut self.p2wshindex_to_height,
         ]
     }
 }

crates/brk_query/src/index.rs

@@ -24,10 +24,15 @@ pub enum Index {
     Decadeindex,
     Difficultyepoch,
     Halvingepoch,
+    Emptyindex,
+    Multisigindex,
+    Opreturnindex,
+    Pushonlyindex,
+    Unknownindex,
 }
 
 impl Index {
-    pub fn all() -> [Self; 20] {
+    pub fn all() -> [Self; 25] {
         [
             Self::Height,
             Self::Dateindex,
@@ -49,6 +54,11 @@ impl Index {
             Self::Txindex,
             Self::Txinindex,
             Self::Txoutindex,
+            Self::Emptyindex,
+            Self::Multisigindex,
+            Self::Opreturnindex,
+            Self::Pushonlyindex,
+            Self::Unknownindex,
         ]
     }
 
@@ -75,6 +85,11 @@ impl Index {
             Self::P2TRindex => &["p2tr", "p2trindex"],
             Self::P2WPKHindex => &["p2wpkh", "p2wpkhindex"],
             Self::P2WSHindex => &["p2wsh", "p2wshindex"],
+            Self::Emptyindex => &["empty", "emptyindex"],
+            Self::Multisigindex => &["multisig", "multisigindex"],
+            Self::Opreturnindex => &["opreturn", "opreturnindex"],
+            Self::Pushonlyindex => &["pushonly", "pushonlyindex"],
+            Self::Unknownindex => &["unknown", "unknownindex"],
         }
     }
 
@@ -122,6 +137,12 @@ impl TryFrom<&str> for Index {
             v if (Self::Difficultyepoch).possible_values().contains(&v) => Self::Difficultyepoch,
             v if (Self::Halvingepoch).possible_values().contains(&v) => Self::Halvingepoch,
             v if (Self::Quarterindex).possible_values().contains(&v) => Self::Quarterindex,
+            v if (Self::Quarterindex).possible_values().contains(&v) => Self::Quarterindex,
+            v if (Self::Emptyindex).possible_values().contains(&v) => Self::Emptyindex,
+            v if (Self::Multisigindex).possible_values().contains(&v) => Self::Multisigindex,
+            v if (Self::Opreturnindex).possible_values().contains(&v) => Self::Opreturnindex,
+            v if (Self::Pushonlyindex).possible_values().contains(&v) => Self::Pushonlyindex,
+            v if (Self::Unknownindex).possible_values().contains(&v) => Self::Unknownindex,
             _ => return Err(eyre!("Bad index")),
         })
     }

crates/brk_query/src/vec_trees.rs

@@ -17,6 +17,7 @@ impl<'a> VecTrees<'a> {
         let file_name = vec.file_name();
         let split = file_name.split("_to_").collect::<Vec<_>>();
         if split.len() != 2 {
+            dbg!(&file_name, &split);
             panic!();
         }
         let str = vec

crates/brk_server/Cargo.toml

@@ -23,8 +23,7 @@ log = { workspace = true }
 minreq = { workspace = true }
 oxc = { version = "0.62.0", features = ["codegen", "minifier"] }
 serde = { workspace = true }
-tokio = { version = "1.44.1", features = ["full"] }
+tokio = { version = "1.44.2", features = ["full"] }
 tower-http = { version = "0.6.2", features = ["compression-full", "trace"] }
-zip = "2.6.0"
+zip = "2.6.1"
 tracing = "0.1.41"
-tracing-subscriber = "0.3.19"

crates/brk_server/examples/main.rs

@@ -10,7 +10,6 @@ use brk_parser::{
     rpc::{self, RpcApi},
 };
 use brk_server::{Server, Website};
-use log::info;
 
 pub fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
@@ -60,14 +59,10 @@ pub fn main() -> color_eyre::Result<()> {
                 loop {
                     let block_count = rpc.get_block_count()?;
 
-                    info!("{block_count} blocks found.");
-
                     let starting_indexes = indexer.index(&parser, rpc, &exit)?;
 
                     computer.compute(&mut indexer, starting_indexes, &exit)?;
 
-                    info!("Waiting for new blocks...");
-
                     while block_count == rpc.get_block_count()? {
                         sleep(Duration::from_secs(1))
                     }

crates/brk_server/src/lib.rs

@@ -129,15 +129,14 @@ impl Server {
                     let status = response.status();
                     let uri = response.extensions().get::<Uri>().unwrap();
                     match status {
-                        StatusCode::INTERNAL_SERVER_ERROR => {
-                            error!("{} {} {:?}", status.as_u16().red(), uri, latency)
-                        }
-                        StatusCode::NOT_MODIFIED => {
-                            info!("{} {} {:?}", status.as_u16().bright_black(), uri, latency)
-                        }
                         StatusCode::OK => {
                             info!("{} {} {:?}", status.as_u16().green(), uri, latency)
                         }
+                        StatusCode::NOT_MODIFIED
+                        | StatusCode::TEMPORARY_REDIRECT
+                        | StatusCode::PERMANENT_REDIRECT => {
+                            info!("{} {} {:?}", status.as_u16().bright_black(), uri, latency)
+                        }
                         _ => error!("{} {} {:?}", status.as_u16().red(), uri, latency),
                     }
                 },

crates/brk_vec/examples/main.rs

@@ -7,7 +7,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     {
         let mut vec: StorableVec<usize, u32> =
-            StorableVec::forced_import(Path::new("./vec"), Version::ONE, Compressed::YES)?;
+            StorableVec::forced_import(Path::new("./vec"), Version::ZERO, Compressed::YES)?;
 
         (0..21_u32).for_each(|v| {
             vec.push(v);
@@ -21,7 +21,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     {
         let mut vec: StorableVec<usize, u32> =
-            StorableVec::forced_import(Path::new("./vec"), Version::ONE, Compressed::YES)?;
+            StorableVec::forced_import(Path::new("./vec"), Version::ZERO, Compressed::YES)?;
 
         dbg!(vec.get(0)?);
         dbg!(vec.get(0)?);
@@ -43,7 +43,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     {
         let mut vec: StorableVec<usize, u32> =
-            StorableVec::forced_import(Path::new("./vec"), Version::ONE, Compressed::YES)?;
+            StorableVec::forced_import(Path::new("./vec"), Version::ZERO, Compressed::YES)?;
 
         vec.enable_large_cache();
 

crates/brk_vec/src/enums/error.rs

@@ -20,7 +20,7 @@ pub enum Error {
     ExpectVecToHaveIndex,
     FailedKeyTryIntoUsize,
     UnsupportedUnflushedState,
-    RangeFromAfterTo,
+    RangeFromAfterTo(usize, usize),
     DifferentCompressionMode,
 }
 
@@ -66,7 +66,7 @@ impl fmt::Display for Error {
                 )
             }
             Error::ZeroCopyError => write!(f, "Zero copy convert error"),
-            Error::RangeFromAfterTo => write!(f, "Range, from is after to"),
+            Error::RangeFromAfterTo(from, to) => write!(f, "Range, from {from} is after to {to}"),
             Error::DifferentCompressionMode => write!(f, "Different compression mode chosen"),
         }
     }

crates/brk_vec/src/lib.rs

@@ -224,7 +224,7 @@ where
         });
 
         if from > to {
-            return Err(Error::RangeFromAfterTo);
+            return Err(Error::RangeFromAfterTo(from, to));
         }
 
         let mut page: Option<(usize, Values<T>)> = None;

publish.sh

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-
-cargo clean
-
-cargo build --all-targets
-
-cd crates/brk
-
-cd ../brk_core
-cargo publish
-
-cd ../brk_exit
-cargo publish
-
-cd ../brk_vec
-cargo publish
-
-cd ../brk_logger
-cargo publish
-
-cd ../brk_indexer
-cargo publish
-
-cd ../brk_parser
-cargo publish
-
-cd ../brk_fetcher
-cargo publish
-
-cd ../brk_computer
-cargo publish
-
-cd ../brk_query
-cargo publish
-
-cd ../brk_server
-cargo publish
-
-cd ../brk_cli
-cargo publish
-
-cd ../brk
-cargo publish
-
-cd ../..

update.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
 
+cargo clean
 rustup update
 cargo upgrade --incompatible
 cargo update
+cargo build --all-targets

websites/kibo.money/scripts/options.js

@@ -644,6 +644,167 @@ function initGroups() {
  * @returns {PartialOptionsTree}
  */
 function createPartialOptions(colors) {
+  /**
+   * @typedef {"total-"} TotalPrefix
+   * @typedef {Extract<VecId, `${TotalPrefix}${string}`>} TotalVecId
+   * @typedef {"-sum"} SumSuffix
+   * @typedef {Extract<VecId, `${string}${SumSuffix}`>} VecIdSum
+   * @typedef {"-average"} AverageSuffix
+   * @typedef {Extract<VecId, `${string}${AverageSuffix}`>} VecIdAverage
+   * @typedef {"-median"} MedianSuffix
+   * @typedef {Extract<VecId, `${string}${MedianSuffix}`>} VecIdMedian
+   * @typedef {"-90p"} _90pSuffix
+   * @typedef {Extract<VecId, `${string}${_90pSuffix}`>} VecId90p
+   * @typedef {"-75p"} _75pSuffix
+   * @typedef {Extract<VecId, `${string}${_75pSuffix}`>} VecId75p
+   * @typedef {"-25p"} _25pSuffix
+   * @typedef {Extract<VecId, `${string}${_25pSuffix}`>} VecId25p
+   * @typedef {"-10p"} _10pSuffix
+   * @typedef {Extract<VecId, `${string}${_10pSuffix}`>} VecId10p
+   * @typedef {"-max"} MaxSuffix
+   * @typedef {Extract<VecId, `${string}${MaxSuffix}`>} VecIdMax
+   * @typedef {"-min"} MinSuffix
+   * @typedef {Extract<VecId, `${string}${MinSuffix}`>} VecIdMin
+   * @typedef {VecId extends infer X
+      ? X extends string
+        ? `${X}${SumSuffix}` extends VecIdSum
+          ? `${TotalPrefix}${X}` extends TotalVecId
+            ? X
+            : never
+          : never
+        : never
+      : never} BaseTotalSumVecId
+   * @typedef {VecId extends infer X
+      ? X extends string
+        ? `${X}${MinSuffix}` extends VecIdMin
+          ? `${X}${MaxSuffix}` extends VecIdMax
+            ? X
+            : never
+          : never
+        : never
+      : never} MinMaxVecId
+    * @typedef {VecId extends infer X
+      ? X extends string
+        ? `${X}${AverageSuffix}` extends VecIdAverage
+          ? X
+          : never
+        : never
+      : never} AverageVecId
+    * @typedef {VecId extends infer X
+      ? X extends string
+        ? `${X}${MedianSuffix}` extends VecIdMedian
+          ? X
+          : never
+        : never
+      : never} MedianVecId
+    * @typedef {VecId extends infer X
+        ? X extends string
+          ? `${X}${_90pSuffix}` extends VecId90p
+            ? `${X}${_75pSuffix}` extends VecId75p
+              ? `${X}${_25pSuffix}` extends VecId25p
+                ? `${X}${_10pSuffix}` extends VecId10p
+                  ? X
+                  : never
+                : never
+              : never
+            : never
+          : never
+        : never} PercentilesVecId
+   * @typedef {AverageVecId & MinMaxVecId & MedianVecId & PercentilesVecId} AverageMinMaxPercentilesVecId
+   */
+
+  /**
+   * @template {BaseTotalSumVecId} T
+   * @param {Object} args
+   * @param {string} args.name
+   * @param {string} args.title
+   * @param {T} args.key
+   */
+  function createBaseSumTotal({ name, title, key }) {
+    return /** @satisfies {PartialChartOption} */ ({
+      name,
+      title,
+      bottom: [
+        { key, title: name, color: colors.bitcoin },
+        {
+          key: `${key}-sum`,
+          title: "Sum",
+          color: colors.bitcoin,
+        },
+        {
+          key: `total-${key}`,
+          title: "Total",
+          color: colors.offBitcoin,
+          defaultActive: false,
+        },
+      ],
+    });
+  }
+
+  /**
+   * @template {AverageMinMaxPercentilesVecId} T
+   * @param {Object} args
+   * @param {string} args.name
+   * @param {string} args.title
+   * @param {T} args.key
+   */
+  function createBaseAverageMinMaxPercentiles({ name, title, key }) {
+    return /** @satisfies {PartialChartOption} */ ({
+      name,
+      title,
+      bottom: [
+        { key, title: name, color: colors.bitcoin },
+        {
+          key: `${key}-average`,
+          title: "Average",
+          color: colors.orange,
+        },
+        {
+          key: `${key}-median`,
+          title: "Median",
+          color: colors.amber,
+          defaultActive: false,
+        },
+        {
+          key: `${key}-75p`,
+          title: "75p",
+          color: colors.red,
+          defaultActive: false,
+        },
+        {
+          key: `${key}-25p`,
+          title: "25p",
+          color: colors.yellow,
+          defaultActive: false,
+        },
+        {
+          key: `${key}-90p`,
+          title: "90p",
+          color: colors.rose,
+          defaultActive: false,
+        },
+        {
+          key: `${key}-10p`,
+          title: "10p",
+          color: colors.lime,
+          defaultActive: false,
+        },
+        {
+          key: `${key}-max`,
+          title: "Max",
+          color: colors.pink,
+          defaultActive: false,
+        },
+        {
+          key: `${key}-min`,
+          title: "Min",
+          color: colors.green,
+          defaultActive: false,
+        },
+      ],
+    });
+  }
+
   return [
     {
       name: "Charts",
@@ -667,74 +828,54 @@ function createPartialOptions(colors) {
         {
           name: "Blocks",
           tree: [
-            {
+            createBaseSumTotal({
               name: "Count",
               title: "Block Count",
-              bottom: [
+              key: "block-count",
-                { key: "block-count", title: "Count", color: colors.bitcoin },
+            }),
-                {
+            createBaseAverageMinMaxPercentiles({
-                  key: "total-block-count",
+              name: "Interval",
-                  title: "Total",
+              title: "Block Interval",
-                  color: colors.bitcoin,
+              key: "block-interval",
-                },
+            }),
+            createBaseSumTotal({
+              name: "Size",
+              title: "Block Size",
+              key: "block-size",
+            }),
+            createBaseSumTotal({
+              name: "Weight",
+              title: "Block Weight",
+              key: "block-weight",
+            }),
+            createBaseSumTotal({
+              name: "Vbytes",
+              title: "Block Virtual Bytes",
+              key: "block-vbytes",
+            }),
+          ],
+        },
+        {
+          name: "Transactions",
+          tree: [
+            {
+              name: "Inputs",
+              tree: [
+                createBaseSumTotal({
+                  name: "Count",
+                  title: "Transaction Input Count",
+                  key: "input-count",
+                }),
               ],
             },
             {
-              name: "Interval",
+              name: "Outputs",
-              title: "Block Interval",
+              tree: [
-              bottom: [
+                createBaseSumTotal({
-                {
+                  name: "Count",
-                  key: "block-interval",
+                  title: "Transaction Output Count",
-                  title: "Interval",
+                  key: "output-count",
-                  color: colors.bitcoin,
+                }),
-                },
-                {
-                  key: "block-interval-average",
-                  title: "Average",
-                  color: colors.orange,
-                },
-                {
-                  key: "block-interval-median",
-                  title: "Median",
-                  color: colors.amber,
-                  defaultActive: false,
-                },
-                {
-                  key: "block-interval-75p",
-                  title: "75p",
-                  color: colors.red,
-                  defaultActive: false,
-                },
-                {
-                  key: "block-interval-25p",
-                  title: "25p",
-                  color: colors.yellow,
-                  defaultActive: false,
-                },
-                {
-                  key: "block-interval-90p",
-                  title: "90p",
-                  color: colors.rose,
-                  defaultActive: false,
-                },
-                {
-                  key: "block-interval-10p",
-                  title: "10p",
-                  color: colors.lime,
-                  defaultActive: false,
-                },
-                {
-                  key: "block-interval-max",
-                  title: "Max",
-                  color: colors.pink,
-                  defaultActive: false,
-                },
-                {
-                  key: "block-interval-min",
-                  title: "Min",
-                  color: colors.green,
-                  defaultActive: false,
-                },
               ],
             },
           ],
@@ -754,6 +895,10 @@ function createPartialOptions(colors) {
     {
       name: "Social",
       tree: [
+        {
+          name: "Github",
+          url: () => "https://github.com/bitcoinresearchkit/brk",
+        },
         {
           name: "Nostr",
           url: () =>
@@ -767,6 +912,10 @@ function createPartialOptions(colors) {
           name: "Bluesky",
           url: () => "https://bsky.app/profile/bitcoinresearchkit.org",
         },
+        {
+          name: "x",
+          url: () => "https://x.com/brkdotorg",
+        },
       ],
     },
     {
@@ -777,9 +926,17 @@ function createPartialOptions(colors) {
           url: () => "/api",
         },
         {
-          name: "Github",
+          name: "Source",
           url: () => "https://github.com/bitcoinresearchkit/brk",
         },
+        {
+          name: "Status",
+          url: () => "https://status.kibo.money/",
+        },
+        {
+          name: "Crate",
+          url: () => "https://crates.io/crates/brk",
+        },
       ],
     },
     {
@@ -1081,6 +1238,12 @@ export function initOptions({
               anyPartial.unit = "Satoshis";
             } else if (key.includes("count")) {
               anyPartial.unit = "Count";
+            } else if (key.includes("-size")) {
+              anyPartial.unit = "Megabytes";
+            } else if (key.includes("-weight")) {
+              anyPartial.unit = "Weight";
+            } else if (key.includes("-vbytes")) {
+              anyPartial.unit = "Virtual Bytes";
             } else {
               console.log(anyPartial);
               throw Error("Unit not set");

websites/kibo.money/scripts/vecid-to-indexes.js

@@ -22,8 +22,13 @@
 /** @typedef {17} Txindex */
 /** @typedef {18} Txinindex */
 /** @typedef {19} Txoutindex */
+/** @typedef {20} Emptyindex */
+/** @typedef {21} Multisigindex */
+/** @typedef {22} Opreturnindex */
+/** @typedef {23} Pushonlyindex */
+/** @typedef {24} Unknownindex */
 
-/** @typedef {Height | Dateindex | Weekindex | Difficultyepoch | Monthindex | Quarterindex | Yearindex | Decadeindex | Halvingepoch | Addressindex | P2PK33index | P2PK65index | P2PKHindex | P2SHindex | P2TRindex | P2WPKHindex | P2WSHindex | Txindex | Txinindex | Txoutindex} Index */
+/** @typedef {Height | Dateindex | Weekindex | Difficultyepoch | Monthindex | Quarterindex | Yearindex | Decadeindex | Halvingepoch | Addressindex | P2PK33index | P2PK65index | P2PKHindex | P2SHindex | P2TRindex | P2WPKHindex | P2WSHindex | Txindex | Txinindex | Txoutindex | Emptyindex | Multisigindex | Opreturnindex | Pushonlyindex | Unknownindex} Index */
 
 export function createVecIdToIndexes() {
   const Height = /** @satisfies {Height} */ (0);
@@ -46,13 +51,19 @@ export function createVecIdToIndexes() {
   const Txindex = /** @satisfies {Txindex} */ (17);
   const Txinindex = /** @satisfies {Txinindex} */ (18);
   const Txoutindex = /** @satisfies {Txoutindex} */ (19);
+  const Emptyindex = /** @satisfies {Emptyindex} */ (20);
+  const Multisigindex = /** @satisfies {Multisigindex} */ (21);
+  const Opreturnindex = /** @satisfies {Opreturnindex} */ (22);
+  const Pushonlyindex = /** @satisfies {Pushonlyindex} */ (23);
+  const Unknownindex = /** @satisfies {Unknownindex} */ (24);
 
   return {
     addressindex: [Txoutindex],
     addresstype: [Addressindex],
     addresstypeindex: [Addressindex],
     "base-size": [Txindex],
-    "block-count": [Dateindex],
+    "block-count": [Height],
+    "block-count-sum": [Dateindex, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     "block-interval": [Height],
     "block-interval-10p": [Dateindex],
     "block-interval-25p": [Dateindex],
@@ -62,6 +73,12 @@ export function createVecIdToIndexes() {
     "block-interval-max": [Dateindex, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     "block-interval-median": [Dateindex],
     "block-interval-min": [Dateindex, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "block-size": [Height],
+    "block-size-sum": [Dateindex, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "block-vbytes": [Height],
+    "block-vbytes-sum": [Dateindex, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "block-weight": [Height],
+    "block-weight-sum": [Dateindex, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     blockhash: [Height],
     close: [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     "close-in-cents": [Dateindex, Height],
@@ -93,10 +110,11 @@ export function createVecIdToIndexes() {
     "fixed-date": [Height],
     "fixed-timestamp": [Height],
     halvingepoch: [Height, Halvingepoch],
-    height: [Addressindex, Height, Txindex],
+    height: [Addressindex, Height, P2PK33index, P2PK65index, P2PKHindex, P2SHindex, P2TRindex, P2WPKHindex, P2WSHindex, Txindex, Txinindex, Txoutindex, Emptyindex, Multisigindex, Opreturnindex, Pushonlyindex, Unknownindex],
     high: [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     "high-in-cents": [Dateindex, Height],
-    "inputs-count": [Txindex],
+    "input-count": [Txindex],
+    "input-count-sum": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     "is-coinbase": [Txindex],
     "is-explicitly-rbf": [Txindex],
     "last-dateindex": [Weekindex, Monthindex],
@@ -114,7 +132,8 @@ export function createVecIdToIndexes() {
     "ohlc-in-cents": [Dateindex, Height],
     open: [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     "open-in-cents": [Dateindex, Height],
-    "outputs-count": [Txindex],
+    "output-count": [Txindex],
+    "output-count-sum": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     p2pk33addressbytes: [P2PK33index],
     p2pk65addressbytes: [P2PK65index],
     p2pkhaddressbytes: [P2PKHindex],
@@ -124,17 +143,20 @@ export function createVecIdToIndexes() {
     p2wshaddressbytes: [P2WSHindex],
     quarterindex: [Monthindex, Quarterindex],
     "real-date": [Height],
-    "sats-per-dollar": [Dateindex, Height],
+    "sats-per-dollar": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
-    size: [Height],
     timestamp: [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch, Halvingepoch],
-    "total-block-count": [Dateindex],
+    "total-block-count": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "total-block-size": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "total-block-vbytes": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "total-block-weight": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "total-input-count": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
+    "total-output-count": [Dateindex, Height, Weekindex, Monthindex, Quarterindex, Yearindex, Decadeindex, Difficultyepoch],
     "total-size": [Txindex],
     txid: [Txindex],
     txoutindex: [Txinindex],
     txversion: [Txindex],
     value: [Txoutindex],
     weekindex: [Dateindex, Weekindex],
-    weight: [Height],
     yearindex: [Monthindex, Yearindex],
   }
 }