release: v0.0.32

.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-latest"
+    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-latest"
+    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-latest"
+    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-latest"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive

.gitignore

@@ -29,11 +29,9 @@ docker/kibo
 
 # Types
 paths.d.ts
-vecid-to-indexes.d.ts
 
 # Outputs
 _outputs
 
-
 # Logs
 .log

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.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.12"
+package.version = "0.0.32"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 
 [profile.release]
@@ -12,7 +12,11 @@ lto = "fat"
 codegen-units = 1
 panic = "abort"
 
+[profile.dist]
+inherits = "release"
+
 [workspace.dependencies]
+axum = "0.8.4"
 bitcoin = { version = "0.32.5", features = ["serde"] }
 bitcoincore-rpc = "0.19.0"
 brk_cli = { version = "0", path = "crates/brk_cli" }
@@ -27,15 +31,43 @@ brk_query = { version = "0", path = "crates/brk_query" }
 brk_server = { version = "0", path = "crates/brk_server" }
 brk_vec = { version = "0", path = "crates/brk_vec" }
 byteview = "0.6.1"
-clap = { version = "4.5.35", features = ["derive", "string"] }
-color-eyre = "0.6.3"
+clap = { version = "4.5.37", features = ["string"] }
+clap_derive = "4.5.32"
+color-eyre = "0.6.4"
 derive_deref = "1.1.1"
-fjall = "2.8.0"
-jiff = "0.2.5"
+fjall = "2.10.0"
+jiff = "0.2.13"
 log = { version = "0.4.27" }
-minreq = { version = "2.13.3", features = ["https", "serde_json"] }
+minreq = { version = "2.13.4", features = ["https", "serde_json"] }
 rayon = "1.10.0"
-serde = { version = "1.0.219", features = ["derive"] }
+serde = { version = "1.0.219" }
+serde_derive = "1.0.219"
 serde_json = { version = "1.0.140", features = ["float_roundtrip"] }
-tabled = "0.18.0"
-zerocopy = { version = "0.8.24", features = ["derive"] }
+tabled = "0.19.0"
+zerocopy = { version = "0.8.25" }
+zerocopy-derive = "0.8.25"
+
+[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",
+]
+
+[workspace.metadata.dist.github-custom-runners]
+global = "ubuntu-latest"
+aarch64-apple-darwin.runner = "macos-14"
+x86_64-unknown-linux-gnu.runner = "ubuntu-latest"
+x86_64-unknown-linux-gnu.container = { image = "quay.io/pypa/manylinux_2_28_x86_64", host = "x86_64-unknown-linux-musl" }
+aarch64-unknown-linux-gnu.runner = "ubuntu-latest"
+aarch64-unknown-linux-gnu.container = { image = "quay.io/pypa/manylinux_2_28_x86_64", host = "x86_64-unknown-linux-musl" }

README.md

@@ -20,7 +20,7 @@
   <a href="https://deps.rs/crate/brk">
     <img src="https://deps.rs/crate/brk/latest/status.svg" alt="Dependency status">
   </a>
-  <a href="https://discord.gg/Cvrwpv3zEG">
+  <a href="https://discord.gg/HaR3wpH3nr">
     <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
   </a>
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
@@ -29,11 +29,19 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>
 
+> **WARNING**
+>
+> This project is still a work in progress and while it's much better in many ways than its previous version ([kibo v0.5](https://github.com/kibo-money/kibo)), it doesn't yet include all of those datasets. If you're interested in having everything right now, please use the latter until feature parity is achieved.
+>
+> The explorer part (mempool.space/electrs) is also not viable just yet.
+>
+> Stay tuned and please be patient, it's a lot of work !
+
 The Bitcoin Research Kit is a high-performance toolchain designed to parse, index, compute, serve and visualize data from a Bitcoin Core node, enabling users to gain deeper insights into the Bitcoin network.
 
 In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) and [electrs](https://github.com/romanz/electrs) all in one package with a particular focus on simplicity and the self-hosting experience.
@@ -50,6 +58,7 @@ The toolkit can be used in various ways to accommodate as many needs as possible
   For more information visit: [`brk_cli`](https://crates.io/crates/brk_cli)
 - **[Crates](https://crates.io/crates/brk)** \
   Rust developers have access to a wide range crates, each built upon one another with its own specific purpose, enabling independent use and offering great flexibility.
+  PRs are welcome, especially if their goal is to introduce additional datasets.
 
 The primary goal of this project is to be fully-featured and accessible for everyone, regardless of their background or financial situation - whether that person is an enthusiast, researcher, miner, analyst, or simply curious.
 
@@ -68,7 +77,7 @@ In contrast, existing alternatives tend to be either [very costly](https://studi
 - [`brk_parser`](https://crates.io/crates/brk_parser): A very fast Bitcoin Core block parser and iterator built on top of bitcoin-rust
 - [`brk_query`](https://crates.io/crates/brk_query): A library that finds requested datasets.
 - [`brk_server`](https://crates.io/crates/brk_server): A server that serves Bitcoin data and swappable front-ends, built on top of `brk_indexer`, `brk_fetcher` and `brk_computer`
-- [`brk_vec`](https://crates.io/crates/brk_vec): A very small, fast, efficient and simple storable Vec.
+- [`brk_vec`](https://crates.io/crates/brk_vec): A push-only, truncable, compressable, saveable Vec
 
 ## Acknowledgments
 
@@ -82,7 +91,8 @@ Heartfelt thanks go out to every donor on [Nostr](https://primal.net/p/npub1jagm
 
 If you'd like to have your own instance hosted for you please contact [hosting@bitcoinresearchkit.org](mailto:hosting@bitcoinresearchkit.org).
 
-- 2 separate servers (1 GB/s each) with different ISPs and Cloudflare integration for enhanced performance and optimal availability
+- 2 separate dedicated servers (1 GB/s each) with different ISPs and Cloudflare integration for enhanced performance and optimal availability
+- 99.9% SLA
 - Direct communication for feature requests and support
 - Updates delivered at your convenience
 - Optional subdomains: `*.bitcoinresearchkit.org`, `*.kibo.money` and `*.satonomics.xyz`

crates/brk_cli/Cargo.toml

@@ -16,13 +16,18 @@ brk_logger = { workspace = true }
 brk_parser = { workspace = true }
 brk_query = { workspace = true }
 brk_server = { workspace = true }
-clap = { workspace = true, features = ["string"] }
+brk_vec = { workspace = true }
+clap = { workspace = true }
+clap_derive = { workspace = true }
 color-eyre = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true }
 tabled = { workspace = true }
-toml = "0.8.20"
+toml = "0.8.22"
 
 [[bin]]
 name = "brk"
 path = "src/main.rs"
+
+[package.metadata.dist]
+dist = false

crates/brk_cli/README.md

@@ -20,7 +20,7 @@
   <a href="https://deps.rs/crate/brk_cli">
     <img src="https://deps.rs/crate/brk_cli/latest/status.svg" alt="Dependency status">
   </a>
-  <a href="https://discord.gg/Cvrwpv3zEG">
+  <a href="https://discord.gg/HaR3wpH3nr">
     <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
   </a>
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>
@@ -59,16 +59,28 @@ To be determined
 - Unix based operating system (Mac OS or Linux)
   - Ubuntu users need to install `open-ssl` via `sudo apt install libssl-dev pkg-config`
 
-## Install
+## Download
+
+### Binaries
+
+You can find a pre-built binary for your operating system on the releases page ([link](https://github.com/bitcoinresearchkit/brk/releases/latest)).
+
+### Cargo
 
 ```bash
+# Install
 cargo install brk # or `cargo install brk_cli`, the result is the same
+
+# Update
+cargo install brk # or `cargo install-update -a` if you have `cargo-update` installed
 ```
 
-## Update
+### Source
 
 ```bash
-cargo install brk # or `cargo install-update -a` if you have `cargo-update` installed
+git clone https://github.com/bitcoinresearchkit/brk.git
+cd brk/crates/brk
+cargo run -r
 ```
 
 ## Usage

crates/brk_cli/src/lib.rs

@@ -2,7 +2,8 @@ use std::fs;
 
 use brk_core::{dot_brk_log_path, dot_brk_path};
 use brk_query::Params as QueryArgs;
-use clap::{Parser, Subcommand};
+use clap::Parser;
+use clap_derive::{Parser, Subcommand};
 use query::query;
 use run::{RunConfig, run};
 

crates/brk_cli/src/query.rs

@@ -1,5 +1,4 @@
 use brk_computer::Computer;
-use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
 use brk_query::{Index, Output, Params as QueryParams, Query, Tabled, Value};
 use tabled::settings::Style;
@@ -11,11 +10,11 @@ pub fn query(params: QueryParams) -> color_eyre::Result<()> {
 
     let compressed = config.compressed();
 
-    let mut indexer = Indexer::new(config.indexeddir(), compressed, config.check_collisions())?;
+    let mut indexer = Indexer::new(&config.outputsdir(), compressed, config.check_collisions())?;
     indexer.import_vecs()?;
 
-    let mut computer = Computer::new(config.computeddir(), config.fetcher(), compressed);
-    computer.import_vecs()?;
+    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), compressed);
+    computer.import_vecs(&indexer, config.computation())?;
 
     let query = Query::build(&indexer, &computer);
 

crates/brk_cli/src/run.rs

@@ -12,7 +12,8 @@ use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
 use brk_parser::rpc::{self, Auth, Client, RpcApi};
 use brk_server::{Server, Website, tokio};
-use clap::{Parser, ValueEnum};
+use brk_vec::Computation;
+use clap_derive::{Parser, ValueEnum};
 use color_eyre::eyre::eyre;
 use log::info;
 use serde::{Deserialize, Serialize};
@@ -28,13 +29,13 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
 
     let compressed = config.compressed();
 
-    let mut indexer = Indexer::new(config.indexeddir(), compressed, config.check_collisions())?;
+    let mut indexer = Indexer::new(&config.outputsdir(), compressed, config.check_collisions())?;
     indexer.import_stores()?;
     indexer.import_vecs()?;
 
-    let mut computer = Computer::new(config.computeddir(), config.fetcher(), compressed);
-    computer.import_stores()?;
-    computer.import_vecs()?;
+    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), compressed);
+    computer.import_stores(&indexer)?;
+    computer.import_vecs(&indexer, config.computation())?;
 
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()
@@ -58,10 +59,28 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
             };
 
             if config.process() {
+                let wait_for_synced_node = || -> color_eyre::Result<()> {
+                    let is_synced = || -> color_eyre::Result<bool> {
+                        let info = rpc.get_blockchain_info()?;
+                        Ok(info.headers == info.blocks)
+                    };
+
+                    if !is_synced()? {
+                        info!("Waiting for node to be synced...");
+                        while !is_synced()? {
+                            sleep(Duration::from_secs(1))
+                        }
+                    }
+
+                    Ok(())
+                };
+
                 loop {
+                    wait_for_synced_node()?;
+
                     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)?;
 
@@ -105,6 +124,10 @@ pub struct RunConfig {
     #[arg(short, long)]
     mode: Option<Mode>,
 
+    /// Computation mode for compatible datasets, `lazy` computes data whenever requested without saving it, `eager` computes the data once and saves it to disk, default: Lazy, saved
+    #[arg(short = 'C', long)]
+    computation: Option<Computation>,
+
     /// Activate compression of datasets, set to true to save disk space or false if prioritize speed, default: true, saved
     #[arg(short, long, value_name = "BOOL")]
     compressed: Option<bool>,
@@ -272,9 +295,10 @@ impl RunConfig {
     }
 
     fn read(path: &Path) -> Self {
-        fs::read_to_string(path).map_or(RunConfig::default(), |contents| {
-            toml::from_str(&contents).unwrap_or_default()
-        })
+        fs::read_to_string(path).map_or_else(
+            |_| RunConfig::default(),
+            |contents| toml::from_str(&contents).unwrap_or_default(),
+        )
     }
 
     fn write(&self, path: &Path) -> std::io::Result<()> {
@@ -338,18 +362,10 @@ impl RunConfig {
             .map_or_else(default_brk_path, |s| Self::fix_user_path(s.as_ref()))
     }
 
-    fn outputsdir(&self) -> PathBuf {
+    pub fn outputsdir(&self) -> PathBuf {
         self.brkdir().join("outputs")
     }
 
-    pub fn indexeddir(&self) -> PathBuf {
-        self.outputsdir().join("indexed")
-    }
-
-    pub fn computeddir(&self) -> PathBuf {
-        self.outputsdir().join("computed")
-    }
-
     pub fn harsdir(&self) -> PathBuf {
         self.outputsdir().join("hars")
     }
@@ -402,6 +418,10 @@ impl RunConfig {
             .then(|| Fetcher::import(Some(self.harsdir().as_path())).unwrap())
     }
 
+    pub fn computation(&self) -> Computation {
+        self.computation.unwrap_or_default()
+    }
+
     pub fn compressed(&self) -> bool {
         self.compressed.is_none_or(|b| b)
     }

crates/brk_computer/Cargo.toml

@@ -14,5 +14,10 @@ brk_indexer = { workspace = true }
 brk_logger = { workspace = true }
 brk_parser = { workspace = true }
 brk_vec = { workspace = true }
+clap = { workspace = true }
+clap_derive = { workspace = true }
 color-eyre = { workspace = true }
+fjall = { workspace = true }
 log = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }

crates/brk_computer/README.md

@@ -20,7 +20,7 @@
   <a href="https://deps.rs/crate/brk_computer">
     <img src="https://deps.rs/crate/brk_computer/latest/status.svg" alt="Dependency status">
   </a>
-  <a href="https://discord.gg/Cvrwpv3zEG">
+  <a href="https://discord.gg/HaR3wpH3nr">
     <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
   </a>
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_computer/examples/main.rs

@@ -6,6 +6,7 @@ use brk_exit::Exit;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
 use brk_parser::{Parser, rpc};
+use brk_vec::Computation;
 
 pub fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
@@ -24,17 +25,17 @@ pub fn main() -> color_eyre::Result<()> {
 
     let outputs_dir = Path::new("../../_outputs");
 
-    let compressed = true;
+    let compressed = false;
 
-    let mut indexer = Indexer::new(outputs_dir.join("indexed"), compressed, true)?;
+    let mut indexer = Indexer::new(outputs_dir, compressed, true)?;
     indexer.import_stores()?;
     indexer.import_vecs()?;
 
     let fetcher = Fetcher::import(None)?;
 
-    let mut computer = Computer::new(outputs_dir.join("computed"), Some(fetcher), compressed);
-    computer.import_stores()?;
-    computer.import_vecs()?;
+    let mut computer = Computer::new(outputs_dir, Some(fetcher), compressed);
+    computer.import_stores(&indexer)?;
+    computer.import_vecs(&indexer, Computation::Lazy)?;
 
     let starting_indexes = indexer.index(&parser, rpc, &exit)?;
 

crates/brk_computer/src/lib.rs

@@ -12,7 +12,7 @@ pub use brk_parser::rpc;
 
 mod storage;
 
-use brk_vec::Compressed;
+use brk_vec::{AnyCollectableVec, Compressed, Computation};
 use log::info;
 use storage::{Stores, Vecs};
 
@@ -26,9 +26,9 @@ pub struct Computer {
 }
 
 impl Computer {
-    pub fn new(computed_dir: PathBuf, fetcher: Option<Fetcher>, compressed: bool) -> Self {
+    pub fn new(outputs_dir: &Path, fetcher: Option<Fetcher>, compressed: bool) -> Self {
         Self {
-            path: computed_dir,
+            path: outputs_dir.to_owned(),
             fetcher,
             vecs: None,
             stores: None,
@@ -36,10 +36,16 @@ impl Computer {
         }
     }
 
-    pub fn import_vecs(&mut self) -> color_eyre::Result<()> {
+    pub fn import_vecs(
+        &mut self,
+        indexer: &Indexer,
+        computation: Computation,
+    ) -> color_eyre::Result<()> {
         self.vecs = Some(Vecs::import(
-            &self.path.join("vecs"),
+            &self.path.join("vecs/computed"),
+            indexer,
             self.fetcher.is_some(),
+            computation,
             self.compressed,
         )?);
         Ok(())
@@ -47,8 +53,11 @@ impl Computer {
 
     /// Do NOT import multiple times or things will break !!!
     /// Clone struct instead
-    pub fn import_stores(&mut self) -> color_eyre::Result<()> {
-        self.stores = Some(Stores::import(&self.path.join("stores"))?);
+    pub fn import_stores(&mut self, indexer: &Indexer) -> color_eyre::Result<()> {
+        self.stores = Some(Stores::import(
+            &self.path.join("stores"),
+            indexer.keyspace(),
+        )?);
         Ok(())
     }
 }
@@ -72,17 +81,14 @@ impl Computer {
         Ok(())
     }
 
-    pub fn path(&self) -> &Path {
-        &self.path
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        // pub fn vecs(&self) -> &Vecs {
+        self.vecs.as_ref().unwrap().vecs()
     }
 
-    pub fn vecs(&self) -> &Vecs {
-        self.vecs.as_ref().unwrap()
-    }
-
-    pub fn mut_vecs(&mut self) -> &mut Vecs {
-        self.vecs.as_mut().unwrap()
-    }
+    // pub fn mut_vecs(&mut self) -> &mut Vecs {
+    //     self.vecs.as_mut().unwrap()
+    // }
 
     pub fn stores(&self) -> &Stores {
         self.stores.as_ref().unwrap()

crates/brk_computer/src/storage/stores.rs

@@ -1,23 +1,31 @@
 use std::path::Path;
 
-use brk_core::{AddressindexTxoutindex, Unit};
-use brk_indexer::Store;
-use brk_vec::Version;
+use fjall::TransactionalKeyspace;
 
 #[derive(Clone)]
 pub struct Stores {
-    pub address_to_utxos_received: Store<AddressindexTxoutindex, Unit>,
-    pub address_to_utxos_spent: Store<AddressindexTxoutindex, Unit>,
+    // pub address_to_utxos_received: Store<AddressIndexOutputIndex, Unit>,
+    // pub address_to_utxos_spent: Store<AddressIndexOutputIndex, Unit>,
 }
 
 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::from(1))?;
-        let address_to_utxos_spent = Store::import(&path.join("address_to_utxos_spent"), Version::from(1))?;
+    pub fn import(_: &Path, _: &TransactionalKeyspace) -> color_eyre::Result<Self> {
+        // let address_to_utxos_received = Store::import(
+        //     keyspace.clone(),
+        //     path,
+        //     "address_to_utxos_received",
+        //     Version::ZERO,
+        // )?;
+        // let address_to_utxos_spent = Store::import(
+        //     keyspace.clone(),
+        //     path,
+        //     "address_to_utxos_spent",
+        //     Version::ZERO,
+        // )?;
 
         Ok(Self {
-            address_to_utxos_received,
-            address_to_utxos_spent,
+            // address_to_utxos_received,
+            // address_to_utxos_spent,
         })
     }
 }

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

@@ -1,330 +0,0 @@
-use core::error;
-use std::{
-    cmp::Ordering,
-    fmt::Debug,
-    io,
-    ops::{Add, Sub},
-    path::{Path, PathBuf},
-};
-
-use brk_core::CheckedSub;
-use brk_exit::Exit;
-use brk_vec::{AnyStorableVec, Compressed, Error, Result, StoredIndex, StoredType, Version};
-
-const FLUSH_EVERY: usize = 10_000;
-
-#[derive(Debug)]
-pub struct StorableVec<I, T> {
-    computed_version: Option<Version>,
-    vec: brk_vec::StorableVec<I, T>,
-}
-
-impl<I, T> StorableVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    pub fn forced_import(
-        path: &Path,
-        version: Version,
-        compressed: Compressed,
-    ) -> brk_vec::Result<Self> {
-        let vec = brk_vec::StorableVec::forced_import(path, version, compressed)?;
-
-        Ok(Self {
-            computed_version: None,
-            vec,
-        })
-    }
-
-    fn safe_truncate_if_needed(&mut self, index: I, exit: &Exit) -> Result<()> {
-        if exit.triggered() {
-            return Ok(());
-        }
-        exit.block();
-        self.vec.truncate_if_needed(index)?;
-        exit.release();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn forced_push_at(&mut self, index: I, value: T, exit: &Exit) -> Result<()> {
-        match self.len().cmp(&index.to_usize()?) {
-            Ordering::Less => {
-                return Err(Error::IndexTooHigh);
-            }
-            ord => {
-                if ord == Ordering::Greater {
-                    self.safe_truncate_if_needed(index, exit)?;
-                }
-                self.vec.push(value);
-            }
-        }
-
-        if self.vec.pushed_len() >= FLUSH_EVERY {
-            Ok(self.safe_flush(exit)?)
-        } else {
-            Ok(())
-        }
-    }
-
-    pub fn safe_flush(&mut self, exit: &Exit) -> io::Result<()> {
-        if exit.triggered() {
-            return Ok(());
-        }
-        exit.block();
-        self.vec.flush()?;
-        exit.release();
-        Ok(())
-    }
-
-    fn version(&self) -> Version {
-        self.vec.version()
-    }
-
-    pub fn len(&self) -> usize {
-        self.vec.len()
-    }
-
-    pub fn vec(&self) -> &brk_vec::StorableVec<I, T> {
-        &self.vec
-    }
-
-    pub fn mut_vec(&mut self) -> &mut brk_vec::StorableVec<I, T> {
-        &mut self.vec
-    }
-
-    pub fn any_vec(&self) -> &dyn AnyStorableVec {
-        &self.vec
-    }
-
-    pub fn mut_any_vec(&mut self) -> &mut dyn AnyStorableVec {
-        &mut self.vec
-    }
-
-    pub fn get(&mut self, index: I) -> Result<Option<&T>> {
-        self.vec.get(index)
-    }
-
-    pub fn collect_range(&self, from: Option<i64>, to: Option<i64>) -> Result<Vec<T>> {
-        self.vec.collect_range(from, to)
-    }
-
-    #[inline]
-    fn path_computed_version(&self) -> PathBuf {
-        self.vec.path().join("computed_version")
-    }
-
-    fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
-        let path = self.path_computed_version();
-        if version.validate(path.as_ref()).is_err() {
-            self.vec.reset()?;
-        }
-        version.write(path.as_ref())?;
-        Ok(())
-    }
-
-    pub fn compute_transform<A, B, F>(
-        &mut self,
-        max_from: A,
-        other: &mut brk_vec::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),
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::from(0) + self.version() + other.version(),
-        )?;
-
-        let index = max_from.min(A::from(self.len()));
-        other.iter_from_cloned(index, |(a, b, other)| {
-            let (i, v) = t((a, b, self, other));
-            self.forced_push_at(i, v, exit)
-        })?;
-
-        Ok(self.safe_flush(exit)?)
-    }
-
-    pub fn compute_inverse_more_to_less(
-        &mut self,
-        max_from: T,
-        other: &mut brk_vec::StorableVec<T, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType + StoredIndex,
-        T: StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::from(0) + self.version() + other.version(),
-        )?;
-
-        let index = max_from.min(self.vec.get_last()?.cloned().unwrap_or_default());
-        other.iter_from(index, |(v, i, ..)| {
-            let i = *i;
-            if self.get(i).unwrap().is_none_or(|old_v| *old_v > v) {
-                self.forced_push_at(i, v, exit)
-            } else {
-                Ok(())
-            }
-        })?;
-
-        Ok(self.safe_flush(exit)?)
-    }
-
-    pub fn compute_inverse_less_to_more(
-        &mut self,
-        max_from: T,
-        first_indexes: &mut brk_vec::StorableVec<T, I>,
-        last_indexes: &mut brk_vec::StorableVec<T, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType,
-        T: StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::from(0) + self.version() + first_indexes.version() + last_indexes.version(),
-        )?;
-
-        let index = max_from.min(T::from(self.len()));
-        first_indexes.iter_from(index, |(value, first_index, ..)| {
-            let first_index = (first_index).to_usize()?;
-            let last_index = (last_indexes.get(value)?.unwrap()).to_usize()?;
-            (first_index..last_index)
-                .try_for_each(|index| self.forced_push_at(I::from(index), value, exit))
-        })?;
-
-        Ok(self.safe_flush(exit)?)
-    }
-
-    pub fn compute_last_index_from_first(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut brk_vec::StorableVec<I, T>,
-        final_len: usize,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: Copy + From<usize> + CheckedSub<T> + StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::from(0) + self.version() + first_indexes.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        let one = T::from(1);
-        let mut prev_index: Option<I> = None;
-        first_indexes.iter_from(index, |(i, v, ..)| {
-            if let Some(prev_index) = prev_index.take() {
-                self.forced_push_at(prev_index, v.checked_sub(one).unwrap(), exit)?;
-            }
-            prev_index.replace(i);
-            Ok(())
-        })?;
-        if let Some(prev_index) = prev_index {
-            self.forced_push_at(
-                prev_index,
-                T::from(final_len).checked_sub(one).unwrap(),
-                exit,
-            )?;
-        }
-
-        Ok(self.safe_flush(exit)?)
-    }
-
-    pub fn compute_count_from_indexes<T2>(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut brk_vec::StorableVec<I, T2>,
-        last_indexes: &mut brk_vec::StorableVec<I, T2>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType + Copy + Add<usize, Output = T2> + CheckedSub<T2> + TryInto<T> + Default,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::from(0) + self.version() + first_indexes.version() + last_indexes.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        first_indexes.iter_from(index, |(i, first_index, ..)| {
-            let last_index = last_indexes.get(i)?.unwrap();
-            let count = (*last_index + 1_usize)
-                .checked_sub(*first_index)
-                .unwrap_or_default();
-            self.forced_push_at(i, count.into(), exit)
-        })?;
-
-        Ok(self.safe_flush(exit)?)
-    }
-
-    pub fn compute_is_first_ordered<A>(
-        &mut self,
-        max_from: I,
-        self_to_other: &mut brk_vec::StorableVec<I, A>,
-        other_to_self: &mut brk_vec::StorableVec<A, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType,
-        T: From<bool>,
-        A: StoredIndex + StoredType,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::from(0) + self.version() + self_to_other.version() + other_to_self.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        self_to_other.iter_from(index, |(i, other, ..)| {
-            self.forced_push_at(i, T::from(other_to_self.get(*other)?.unwrap() == &i), exit)
-        })?;
-
-        Ok(self.safe_flush(exit)?)
-    }
-
-    pub fn compute_sum_from_indexes<T2>(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut brk_vec::StorableVec<I, T2>,
-        last_indexes: &mut brk_vec::StorableVec<I, T2>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType + Copy + Add<usize, Output = T2> + Sub<T2, Output = T2> + TryInto<T>,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::from(0) + self.version() + first_indexes.version() + last_indexes.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        first_indexes.iter_from(index, |(index, first_index, ..)| {
-            let last_index = last_indexes.get(index)?.unwrap();
-            let count = *last_index + 1_usize - *first_index;
-            self.forced_push_at(index, count.into(), exit)
-        })?;
-
-        Ok(self.safe_flush(exit)?)
-    }
-}
-
-impl<I, T> Clone for StorableVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    fn clone(&self) -> Self {
-        Self {
-            computed_version: self.computed_version,
-            vec: self.vec.clone(),
-        }
-    }
-}

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

@@ -1,49 +1,111 @@
 use std::{fs, path::Path};
 
-use brk_core::{CheckedSub, Dateindex, Height, Timestamp};
+use brk_core::{
+    CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, StoredUsize,
+    Timestamp, Weight,
+};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{AnyStorableVec, Compressed, Version};
+use brk_parser::bitcoin;
+use brk_vec::{AnyCollectableVec, AnyIterableVec, Compressed, Computation, EagerVec, Version};
 
 use super::{
-    Indexes, StorableVec, indexes,
-    stats::{StorableVecGeneatorOptions, StorableVecsStatsFromHeight},
+    Indexes,
+    grouped::{ComputedVecsFromDateindex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    indexes,
 };
 
 #[derive(Clone)]
 pub struct Vecs {
-    pub height_to_block_interval: StorableVec<Height, Timestamp>,
-    pub indexes_to_block_interval_stats: StorableVecsStatsFromHeight<Timestamp>,
-    pub dateindex_to_block_count: StorableVec<Dateindex, u16>,
-    pub dateindex_to_total_block_count: StorableVec<Dateindex, u32>,
+    pub height_to_interval: EagerVec<Height, Timestamp>,
+    pub height_to_vbytes: EagerVec<Height, StoredU64>,
+    pub difficultyepoch_to_timestamp: EagerVec<DifficultyEpoch, Timestamp>,
+    pub halvingepoch_to_timestamp: EagerVec<HalvingEpoch, Timestamp>,
+    pub timeindexes_to_timestamp: ComputedVecsFromDateindex<Timestamp>,
+    pub indexes_to_block_count: ComputedVecsFromHeight<StoredU32>,
+    pub indexes_to_block_interval: ComputedVecsFromHeight<Timestamp>,
+    pub indexes_to_block_size: ComputedVecsFromHeight<StoredUsize>,
+    pub indexes_to_block_vbytes: ComputedVecsFromHeight<StoredU64>,
+    pub indexes_to_block_weight: ComputedVecsFromHeight<Weight>,
 }
 
 impl Vecs {
-    pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
+    pub fn forced_import(
+        path: &Path,
+        _computation: Computation,
+        compressed: Compressed,
+    ) -> color_eyre::Result<Self> {
         fs::create_dir_all(path)?;
 
         Ok(Self {
-            height_to_block_interval: StorableVec::forced_import(
-                &path.join("height_to_block_interval"),
-                Version::from(1),
+            height_to_interval: EagerVec::forced_import(
+                &path.join("height_to_interval"),
+                Version::ZERO,
                 compressed,
             )?,
-            indexes_to_block_interval_stats: StorableVecsStatsFromHeight::forced_import(
-                &path.join("block_interval"),
+            timeindexes_to_timestamp: ComputedVecsFromDateindex::forced_import(
+                path,
+                "timestamp",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_first(),
+            )?,
+            indexes_to_block_interval: ComputedVecsFromHeight::forced_import(
+                path,
+                "block_interval",
+                false,
+                Version::ZERO,
                 compressed,
                 StorableVecGeneatorOptions::default()
                     .add_percentiles()
                     .add_minmax()
                     .add_average(),
             )?,
-            dateindex_to_block_count: StorableVec::forced_import(
-                &path.join("dateindex_to_block_count"),
-                Version::from(1),
+            indexes_to_block_count: ComputedVecsFromHeight::forced_import(
+                path,
+                "block_count",
+                true,
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
+            )?,
+            indexes_to_block_weight: ComputedVecsFromHeight::forced_import(
+                path,
+                "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(),
+            )?,
+            height_to_vbytes: EagerVec::forced_import(
+                &path.join("height_to_vbytes"),
+                Version::ZERO,
                 compressed,
             )?,
-            dateindex_to_total_block_count: StorableVec::forced_import(
-                &path.join("dateindex_to_total_block_count"),
-                Version::from(1),
+            indexes_to_block_vbytes: ComputedVecsFromHeight::forced_import(
+                path,
+                "block_vbytes",
+                false,
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_sum().add_total(),
+            )?,
+            difficultyepoch_to_timestamp: EagerVec::forced_import(
+                &path.join("difficultyepoch_to_timestamp"),
+                Version::ZERO,
+                compressed,
+            )?,
+            halvingepoch_to_timestamp: EagerVec::forced_import(
+                &path.join("halvingepoch_to_timestamp"),
+                Version::ZERO,
                 compressed,
             )?,
         })
@@ -51,19 +113,52 @@ impl Vecs {
 
     pub fn compute(
         &mut self,
-        indexer: &mut Indexer,
-        indexes: &mut indexes::Vecs,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
     ) -> color_eyre::Result<()> {
-        let indexer_vecs = indexer.mut_vecs();
+        self.timeindexes_to_timestamp.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, indexes, starting_indexes, exit| {
+                vec.compute_transform(
+                    starting_indexes.dateindex,
+                    &indexes.dateindex_to_date,
+                    |(di, d, ..)| (di, Timestamp::from(d)),
+                    exit,
+                )
+            },
+        )?;
 
-        self.height_to_block_interval.compute_transform(
+        self.indexes_to_block_count.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, indexer, _, starting_indexes, exit| {
+                let indexer_vecs = indexer.vecs();
+
+                v.compute_range(
+                    starting_indexes.height,
+                    &indexer_vecs.height_to_weight,
+                    |h| (h, StoredU32::from(1_u32)),
+                    exit,
+                )
+            },
+        )?;
+
+        let indexer_vecs = indexer.vecs();
+
+        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
+        self.height_to_interval.compute_transform(
             starting_indexes.height,
-            indexer_vecs.height_to_timestamp.mut_vec(),
-            |(height, timestamp, _, height_to_timestamp)| {
+            &indexer_vecs.height_to_timestamp,
+            |(height, timestamp, ..)| {
                 let interval = height.decremented().map_or(Timestamp::ZERO, |prev_h| {
-                    let prev_timestamp = *height_to_timestamp.get(prev_h).unwrap().unwrap();
+                    let prev_timestamp = height_to_timestamp_iter.unwrap_get_inner(prev_h);
                     timestamp
                         .checked_sub(prev_timestamp)
                         .unwrap_or(Timestamp::ZERO)
@@ -73,24 +168,79 @@ impl Vecs {
             exit,
         )?;
 
-        self.indexes_to_block_interval_stats.compute(
-            &mut self.height_to_block_interval,
+        self.indexes_to_block_interval.compute_rest(
             indexes,
             starting_indexes,
             exit,
+            Some(&self.height_to_interval),
+        )?;
+
+        self.indexes_to_block_weight.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&indexer_vecs.height_to_weight),
+        )?;
+
+        self.indexes_to_block_size.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&indexer_vecs.height_to_total_size),
+        )?;
+
+        self.height_to_vbytes.compute_transform(
+            starting_indexes.height,
+            &indexer_vecs.height_to_weight,
+            |(h, w, ..)| {
+                (
+                    h,
+                    StoredU64::from(bitcoin::Weight::from(w).to_vbytes_floor()),
+                )
+            },
+            exit,
+        )?;
+
+        self.indexes_to_block_vbytes.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&self.height_to_vbytes),
+        )?;
+
+        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
+
+        self.difficultyepoch_to_timestamp.compute_transform(
+            starting_indexes.difficultyepoch,
+            &indexes.difficultyepoch_to_first_height,
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
+            exit,
+        )?;
+
+        self.halvingepoch_to_timestamp.compute_transform(
+            starting_indexes.halvingepoch,
+            &indexes.halvingepoch_to_first_height,
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
+            exit,
         )?;
 
         Ok(())
     }
 
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         [
             vec![
-                self.height_to_block_interval.any_vec(),
-                self.dateindex_to_block_count.any_vec(),
-                self.dateindex_to_total_block_count.any_vec(),
+                &self.height_to_interval as &dyn AnyCollectableVec,
+                &self.height_to_vbytes,
+                &self.difficultyepoch_to_timestamp,
+                &self.halvingepoch_to_timestamp,
             ],
-            self.indexes_to_block_interval_stats.as_any_vecs(),
+            self.timeindexes_to_timestamp.vecs(),
+            self.indexes_to_block_count.vecs(),
+            self.indexes_to_block_interval.vecs(),
+            self.indexes_to_block_size.vecs(),
+            self.indexes_to_block_vbytes.vecs(),
+            self.indexes_to_block_weight.vecs(),
         ]
         .concat()
     }

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

@@ -0,0 +1,866 @@
+use std::path::Path;
+
+use brk_core::{CheckedSub, StoredUsize};
+use brk_exit::Exit;
+use brk_vec::{
+    AnyCollectableVec, AnyIterableVec, Compressed, EagerVec, Result, StoredIndex, StoredType,
+    Version,
+};
+use color_eyre::eyre::ContextCompat;
+
+use super::ComputedType;
+
+#[derive(Clone, Debug)]
+pub struct ComputedVecBuilder<I, T>
+where
+    I: StoredIndex,
+    T: ComputedType,
+{
+    first: Option<EagerVec<I, T>>,
+    average: Option<EagerVec<I, T>>,
+    sum: Option<EagerVec<I, T>>,
+    max: Option<EagerVec<I, T>>,
+    _90p: Option<EagerVec<I, T>>,
+    _75p: Option<EagerVec<I, T>>,
+    median: Option<EagerVec<I, T>>,
+    _25p: Option<EagerVec<I, T>>,
+    _10p: Option<EagerVec<I, T>>,
+    min: Option<EagerVec<I, T>>,
+    last: Option<EagerVec<I, T>>,
+    total: Option<EagerVec<I, T>>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<I, T> ComputedVecBuilder<I, T>
+where
+    I: StoredIndex,
+    T: ComputedType,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let key = I::to_string().split("::").last().unwrap().to_lowercase();
+
+        let only_one_active = options.is_only_one_active();
+
+        let default = || path.join(format!("{key}_to_{name}"));
+
+        let prefix = |s: &str| path.join(format!("{key}_to_{s}_{name}"));
+
+        let maybe_prefix = |s: &str| {
+            if only_one_active {
+                default()
+            } else {
+                prefix(s)
+            }
+        };
+
+        let suffix = |s: &str| path.join(format!("{key}_to_{name}_{s}"));
+
+        let maybe_suffix = |s: &str| {
+            if only_one_active {
+                default()
+            } else {
+                suffix(s)
+            }
+        };
+
+        let version = VERSION + version;
+
+        let s = Self {
+            first: options.first.then(|| {
+                EagerVec::forced_import(&maybe_prefix("first"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            last: options.last.then(|| {
+                EagerVec::forced_import(
+                    &path.join(format!("{key}_to_{name}")),
+                    version + Version::ZERO,
+                    compressed,
+                )
+                .unwrap()
+            }),
+            min: options.min.then(|| {
+                EagerVec::forced_import(&maybe_suffix("min"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            max: options.max.then(|| {
+                EagerVec::forced_import(&maybe_suffix("max"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            median: options.median.then(|| {
+                EagerVec::forced_import(
+                    &maybe_suffix("median"),
+                    version + Version::ZERO,
+                    compressed,
+                )
+                .unwrap()
+            }),
+            average: options.average.then(|| {
+                EagerVec::forced_import(
+                    &maybe_suffix("average"),
+                    version + Version::ZERO,
+                    compressed,
+                )
+                .unwrap()
+            }),
+            sum: options.sum.then(|| {
+                EagerVec::forced_import(&maybe_suffix("sum"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            total: options.total.then(|| {
+                EagerVec::forced_import(&prefix("total"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            _90p: options._90p.then(|| {
+                EagerVec::forced_import(&maybe_suffix("90p"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            _75p: options._75p.then(|| {
+                EagerVec::forced_import(&maybe_suffix("75p"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            _25p: options._25p.then(|| {
+                EagerVec::forced_import(&maybe_suffix("25p"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+            _10p: options._10p.then(|| {
+                EagerVec::forced_import(&maybe_suffix("10p"), version + Version::ZERO, compressed)
+                    .unwrap()
+            }),
+        };
+
+        Ok(s)
+    }
+
+    pub fn extend(
+        &mut self,
+        max_from: I,
+        source: &impl AnyIterableVec<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();
+
+        let mut total = index.decremented().map_or(T::from(0_usize), |index| {
+            total_vec.iter().unwrap_get_inner(index)
+        });
+        source.iter_at(index).try_for_each(|(i, v)| -> Result<()> {
+            total = total.clone() + v.into_inner();
+            total_vec.forced_push_at(i, total.clone(), exit)
+        })?;
+
+        self.safe_flush(exit)?;
+
+        Ok(())
+    }
+
+    pub fn compute<I2>(
+        &mut self,
+        max_from: I,
+        source: &impl AnyIterableVec<I2, T>,
+        first_indexes: &impl AnyIterableVec<I, I2>,
+        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
+        exit: &Exit,
+    ) -> Result<()>
+    where
+        I2: StoredIndex + StoredType + CheckedSub<I2>,
+    {
+        let index = self.starting_index(max_from);
+
+        self.validate_computed_version_or_reset_file(
+            source.version() + first_indexes.version() + count_indexes.version(),
+        )?;
+
+        let mut count_indexes_iter = count_indexes.iter();
+        let mut source_iter = source.iter();
+
+        let total_vec = self.total.as_mut();
+
+        let mut total = total_vec.map(|total_vec| {
+            index.decremented().map_or(T::from(0_usize), |index| {
+                total_vec.iter().unwrap_get_inner(index)
+            })
+        });
+
+        first_indexes
+            .iter_at(index)
+            .try_for_each(|(i, first_index)| -> Result<()> {
+                let first_index = first_index.into_inner();
+
+                let count_index = count_indexes_iter.unwrap_get_inner(i);
+
+                if let Some(first) = self.first.as_mut() {
+                    let f = source_iter
+                        .get_inner(first_index)
+                        .unwrap_or_else(|| T::from(0_usize));
+                    first.forced_push_at(index, f, exit)?;
+                }
+
+                if let Some(last) = self.last.as_mut() {
+                    let count_index = *count_index;
+                    if count_index == 0 {
+                        panic!("should compute last if count can be 0")
+                    }
+                    let last_index = first_index + (count_index - 1);
+                    let v = source_iter.unwrap_get_inner(last_index);
+                    // .context("to work")
+                    // .inspect_err(|_| {
+                    //     dbg!(first_index, count_index, last_index);
+                    // })
+                    // .unwrap()
+                    // .into_inner();
+                    last.forced_push_at(index, v, exit)?;
+                }
+
+                let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
+                let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
+                let needs_sorted = self.max.is_some()
+                    || self._90p.is_some()
+                    || self._75p.is_some()
+                    || self.median.is_some()
+                    || self._25p.is_some()
+                    || self._10p.is_some()
+                    || self.min.is_some();
+                let needs_values = needs_sorted || needs_average_sum_or_total;
+
+                if needs_values {
+                    source_iter.set(first_index);
+                    let mut values = (&mut source_iter)
+                        .take(*count_index)
+                        .map(|(_, v)| v.into_inner())
+                        .collect::<Vec<_>>();
+
+                    if needs_sorted {
+                        values.sort_unstable();
+
+                        if let Some(max) = self.max.as_mut() {
+                            max.forced_push_at(
+                                i,
+                                values
+                                    .last()
+                                    .context("expect some")
+                                    .inspect_err(|_| {
+                                        dbg!(
+                                            &values,
+                                            max.path(),
+                                            first_indexes.name(),
+                                            first_index,
+                                            count_indexes.name(),
+                                            count_index,
+                                            source.len(),
+                                            source.name()
+                                        );
+                                    })
+                                    .unwrap()
+                                    .clone(),
+                                exit,
+                            )?;
+                        }
+
+                        if let Some(_90p) = self._90p.as_mut() {
+                            _90p.forced_push_at(i, Self::get_percentile(&values, 0.90), exit)?;
+                        }
+
+                        if let Some(_75p) = self._75p.as_mut() {
+                            _75p.forced_push_at(i, Self::get_percentile(&values, 0.75), exit)?;
+                        }
+
+                        if let Some(median) = self.median.as_mut() {
+                            median.forced_push_at(i, Self::get_percentile(&values, 0.50), exit)?;
+                        }
+
+                        if let Some(_25p) = self._25p.as_mut() {
+                            _25p.forced_push_at(i, Self::get_percentile(&values, 0.25), exit)?;
+                        }
+
+                        if let Some(_10p) = self._10p.as_mut() {
+                            _10p.forced_push_at(i, Self::get_percentile(&values, 0.10), exit)?;
+                        }
+
+                        if let Some(min) = self.min.as_mut() {
+                            min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
+                        }
+                    }
+
+                    if needs_average_sum_or_total {
+                        let len = values.len();
+                        let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
+
+                        if let Some(average) = self.average.as_mut() {
+                            let avg = sum.clone() / len;
+                            average.forced_push_at(i, avg, exit)?;
+                        }
+
+                        if needs_sum_or_total {
+                            if let Some(sum_vec) = self.sum.as_mut() {
+                                sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                            }
+
+                            if let Some(total_vec) = self.total.as_mut() {
+                                let t = total.as_ref().unwrap().clone() + sum;
+                                total.replace(t.clone());
+                                total_vec.forced_push_at(i, t, exit)?;
+                            }
+                        }
+                    }
+                }
+
+                Ok(())
+            })?;
+
+        self.safe_flush(exit)?;
+
+        Ok(())
+    }
+
+    #[allow(clippy::wrong_self_convention)]
+    pub fn from_aligned<I2>(
+        &mut self,
+        max_from: I,
+        source: &ComputedVecBuilder<I2, T>,
+        first_indexes: &impl AnyIterableVec<I, I2>,
+        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
+        exit: &Exit,
+    ) -> Result<()>
+    where
+        I2: StoredIndex + StoredType + CheckedSub<I2>,
+    {
+        if self._90p.is_some()
+            || self._75p.is_some()
+            || self.median.is_some()
+            || self._25p.is_some()
+            || self._10p.is_some()
+        {
+            panic!("unsupported");
+        }
+
+        self.validate_computed_version_or_reset_file(
+            VERSION + first_indexes.version() + count_indexes.version(),
+        )?;
+
+        let index = self.starting_index(max_from);
+
+        let mut count_indexes_iter = count_indexes.iter();
+
+        let mut source_first_iter = source.first.as_ref().map(|f| f.iter());
+        let mut source_last_iter = source.last.as_ref().map(|f| f.iter());
+        let mut source_max_iter = source.max.as_ref().map(|f| f.iter());
+        let mut source_min_iter = source.min.as_ref().map(|f| f.iter());
+        let mut source_average_iter = source.average.as_ref().map(|f| f.iter());
+        let mut source_sum_iter = source.sum.as_ref().map(|f| f.iter());
+
+        let mut total = self.total.as_mut().map(|total_vec| {
+            index.decremented().map_or(T::from(0_usize), |index| {
+                total_vec.iter().unwrap_get_inner(index)
+            })
+        });
+
+        first_indexes
+            .iter_at(index)
+            .try_for_each(|(i, first_index, ..)| -> Result<()> {
+                let first_index = first_index.into_inner();
+
+                let count_index = count_indexes_iter.unwrap_get_inner(i);
+
+                if let Some(first) = self.first.as_mut() {
+                    let v = source_first_iter
+                        .as_mut()
+                        .unwrap()
+                        .unwrap_get_inner(first_index);
+                    first.forced_push_at(index, v, exit)?;
+                }
+
+                if let Some(last) = self.last.as_mut() {
+                    let count_index = *count_index;
+                    if count_index == 0 {
+                        panic!("should compute last if count can be 0")
+                    }
+                    let last_index = first_index + (count_index - 1);
+                    let v = source_last_iter
+                        .as_mut()
+                        .unwrap()
+                        .unwrap_get_inner(last_index);
+                    last.forced_push_at(index, v, exit)?;
+                }
+
+                let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
+                let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
+                let needs_sorted = self.max.is_some() || self.min.is_some();
+                let needs_values = needs_sorted || needs_average_sum_or_total;
+
+                if needs_values {
+                    if needs_sorted {
+                        if let Some(max) = self.max.as_mut() {
+                            let source_max_iter = source_max_iter.as_mut().unwrap();
+                            source_max_iter.set(first_index);
+                            let mut values = source_max_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+                            values.sort_unstable();
+                            max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
+                        }
+
+                        if let Some(min) = self.min.as_mut() {
+                            let source_min_iter = source_min_iter.as_mut().unwrap();
+                            source_min_iter.set(first_index);
+                            let mut values = source_min_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+                            values.sort_unstable();
+                            min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
+                        }
+                    }
+
+                    if needs_average_sum_or_total {
+                        if let Some(average) = self.average.as_mut() {
+                            let source_average_iter = source_average_iter.as_mut().unwrap();
+                            source_average_iter.set(first_index);
+                            let values = source_average_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+
+                            let len = values.len();
+                            let total = values.into_iter().fold(T::from(0), |a, b| a + b);
+                            // TODO: Multiply by count then divide by total
+                            // Right now it's not 100% accurate as there could be more or less elements in the lower timeframe (28 days vs 31 days in a month for example)
+                            let avg = total / len;
+                            average.forced_push_at(i, avg, exit)?;
+                        }
+
+                        if needs_sum_or_total {
+                            let source_sum_iter = source_sum_iter.as_mut().unwrap();
+                            source_sum_iter.set(first_index);
+                            let values = source_sum_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+
+                            let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
+
+                            if let Some(sum_vec) = self.sum.as_mut() {
+                                sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                            }
+
+                            if let Some(total_vec) = self.total.as_mut() {
+                                let t = total.as_ref().unwrap().clone() + sum;
+                                total.replace(t.clone());
+                                total_vec.forced_push_at(i, t, exit)?;
+                            }
+                        }
+                    }
+                }
+
+                Ok(())
+            })?;
+
+        self.safe_flush(exit)?;
+
+        Ok(())
+    }
+
+    fn get_percentile(sorted: &[T], percentile: f64) -> T {
+        let len = sorted.len();
+
+        if len == 0 {
+            panic!();
+        } else if len == 1 {
+            sorted[0].clone()
+        } else {
+            let index = (len - 1) as f64 * percentile;
+
+            let fract = index.fract();
+
+            if fract != 0.0 {
+                let left = sorted.get(index as usize).unwrap().clone();
+                let right = sorted.get(index.ceil() as usize).unwrap().clone();
+                left / 2 + right / 2
+            } else {
+                sorted.get(index as usize).unwrap().clone()
+            }
+        }
+    }
+
+    fn starting_index(&self, max_from: I) -> I {
+        max_from.min(I::from(
+            self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
+        ))
+    }
+
+    pub fn unwrap_first(&mut self) -> &mut EagerVec<I, T> {
+        self.first.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_average(&mut self) -> &mut EagerVec<I, T> {
+        self.average.as_mut().unwrap()
+    }
+    pub fn unwrap_sum(&mut self) -> &mut EagerVec<I, T> {
+        self.sum.as_mut().unwrap()
+    }
+    pub fn unwrap_max(&mut self) -> &mut EagerVec<I, T> {
+        self.max.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_90p(&mut self) -> &mut EagerVec<I, T> {
+        self._90p.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_75p(&mut self) -> &mut EagerVec<I, T> {
+        self._75p.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_median(&mut self) -> &mut EagerVec<I, T> {
+        self.median.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_25p(&mut self) -> &mut EagerVec<I, T> {
+        self._25p.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_10p(&mut self) -> &mut EagerVec<I, T> {
+        self._10p.as_mut().unwrap()
+    }
+    pub fn unwrap_min(&mut self) -> &mut EagerVec<I, T> {
+        self.min.as_mut().unwrap()
+    }
+    pub fn unwrap_last(&mut self) -> &mut EagerVec<I, T> {
+        self.last.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_total(&mut self) -> &mut EagerVec<I, T> {
+        self.total.as_mut().unwrap()
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        let mut v: Vec<&dyn AnyCollectableVec> = vec![];
+
+        if let Some(first) = self.first.as_ref() {
+            v.push(first);
+        }
+        if let Some(last) = self.last.as_ref() {
+            v.push(last);
+        }
+        if let Some(min) = self.min.as_ref() {
+            v.push(min);
+        }
+        if let Some(max) = self.max.as_ref() {
+            v.push(max);
+        }
+        if let Some(median) = self.median.as_ref() {
+            v.push(median);
+        }
+        if let Some(average) = self.average.as_ref() {
+            v.push(average);
+        }
+        if let Some(sum) = self.sum.as_ref() {
+            v.push(sum);
+        }
+        if let Some(total) = self.total.as_ref() {
+            v.push(total);
+        }
+        if let Some(_90p) = self._90p.as_ref() {
+            v.push(_90p);
+        }
+        if let Some(_75p) = self._75p.as_ref() {
+            v.push(_75p);
+        }
+        if let Some(_25p) = self._25p.as_ref() {
+            v.push(_25p);
+        }
+        if let Some(_10p) = self._10p.as_ref() {
+            v.push(_10p);
+        }
+
+        v
+    }
+
+    pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {
+        if let Some(first) = self.first.as_mut() {
+            first.safe_flush(exit)?;
+        }
+        if let Some(last) = self.last.as_mut() {
+            last.safe_flush(exit)?;
+        }
+        if let Some(min) = self.min.as_mut() {
+            min.safe_flush(exit)?;
+        }
+        if let Some(max) = self.max.as_mut() {
+            max.safe_flush(exit)?;
+        }
+        if let Some(median) = self.median.as_mut() {
+            median.safe_flush(exit)?;
+        }
+        if let Some(average) = self.average.as_mut() {
+            average.safe_flush(exit)?;
+        }
+        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)?;
+        }
+        if let Some(_75p) = self._75p.as_mut() {
+            _75p.safe_flush(exit)?;
+        }
+        if let Some(_25p) = self._25p.as_mut() {
+            _25p.safe_flush(exit)?;
+        }
+        if let Some(_10p) = self._10p.as_mut() {
+            _10p.safe_flush(exit)?;
+        }
+
+        Ok(())
+    }
+
+    fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
+        if let Some(first) = self.first.as_mut() {
+            first.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(last) = self.last.as_mut() {
+            last.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(min) = self.min.as_mut() {
+            min.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(max) = self.max.as_mut() {
+            max.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(median) = self.median.as_mut() {
+            median.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(average) = self.average.as_mut() {
+            average.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(sum) = self.sum.as_mut() {
+            sum.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(total) = self.total.as_mut() {
+            total.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_90p) = self._90p.as_mut() {
+            _90p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_75p) = self._75p.as_mut() {
+            _75p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_25p) = self._25p.as_mut() {
+            _25p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_10p) = self._10p.as_mut() {
+            _10p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Default, Clone, Copy)]
+pub struct StorableVecGeneatorOptions {
+    average: bool,
+    sum: bool,
+    max: bool,
+    _90p: bool,
+    _75p: bool,
+    median: bool,
+    _25p: bool,
+    _10p: bool,
+    min: bool,
+    first: bool,
+    last: bool,
+    total: bool,
+}
+
+impl StorableVecGeneatorOptions {
+    pub fn add_first(mut self) -> Self {
+        self.first = true;
+        self
+    }
+
+    pub fn add_last(mut self) -> Self {
+        self.last = true;
+        self
+    }
+
+    pub fn add_min(mut self) -> Self {
+        self.min = true;
+        self
+    }
+
+    pub fn add_max(mut self) -> Self {
+        self.max = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn add_median(mut self) -> Self {
+        self.median = true;
+        self
+    }
+
+    pub fn add_average(mut self) -> Self {
+        self.average = true;
+        self
+    }
+
+    pub fn add_sum(mut self) -> Self {
+        self.sum = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn add_90p(mut self) -> Self {
+        self._90p = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn add_75p(mut self) -> Self {
+        self._75p = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn add_25p(mut self) -> Self {
+        self._25p = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn add_10p(mut self) -> Self {
+        self._10p = true;
+        self
+    }
+
+    pub fn add_total(mut self) -> Self {
+        self.total = true;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_min(mut self) -> Self {
+        self.min = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_max(mut self) -> Self {
+        self.max = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_median(mut self) -> Self {
+        self.median = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_average(mut self) -> Self {
+        self.average = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_sum(mut self) -> Self {
+        self.sum = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_90p(mut self) -> Self {
+        self._90p = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_75p(mut self) -> Self {
+        self._75p = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_25p(mut self) -> Self {
+        self._25p = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_10p(mut self) -> Self {
+        self._10p = false;
+        self
+    }
+
+    #[allow(unused)]
+    pub fn rm_total(mut self) -> Self {
+        self.total = false;
+        self
+    }
+
+    pub fn add_minmax(mut self) -> Self {
+        self.min = true;
+        self.max = true;
+        self
+    }
+
+    pub fn add_percentiles(mut self) -> Self {
+        self._90p = true;
+        self._75p = true;
+        self.median = true;
+        self._25p = true;
+        self._10p = true;
+        self
+    }
+
+    pub fn remove_percentiles(mut self) -> Self {
+        self._90p = false;
+        self._75p = false;
+        self.median = false;
+        self._25p = false;
+        self._10p = false;
+        self
+    }
+
+    pub fn is_only_one_active(&self) -> bool {
+        [
+            self.average,
+            self.sum,
+            self.max,
+            self._90p,
+            self._75p,
+            self.median,
+            self._25p,
+            self._10p,
+            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,155 @@
+use std::path::Path;
+
+use brk_core::{DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, Compressed, EagerVec, Result, Version};
+
+use crate::storage::{Indexes, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromDateindex<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub dateindex: EagerVec<DateIndex, T>,
+    pub dateindex_extra: ComputedVecBuilder<DateIndex, T>,
+    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
+    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
+    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    pub yearindex: ComputedVecBuilder<YearIndex, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromDateindex<T>
+where
+    T: ComputedType,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let version = VERSION + version;
+
+        let dateindex_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version,
+            compressed,
+            options.copy_self_extra(),
+        )?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            dateindex: EagerVec::forced_import(
+                &path.join(format!("dateindex_to_{name}")),
+                version,
+                compressed,
+            )?,
+            dateindex_extra,
+            weekindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+        })
+    }
+
+    pub fn compute<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(
+            &mut EagerVec<DateIndex, T>,
+            &Indexer,
+            &indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(
+            &mut self.dateindex,
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        self.dateindex_extra
+            .extend(starting_indexes.dateindex, &self.dateindex, exit)?;
+
+        self.weekindex.compute(
+            starting_indexes.weekindex,
+            &self.dateindex,
+            &indexes.weekindex_to_first_dateindex,
+            &indexes.weekindex_to_dateindex_count,
+            exit,
+        )?;
+
+        self.monthindex.compute(
+            starting_indexes.monthindex,
+            &self.dateindex,
+            &indexes.monthindex_to_first_dateindex,
+            &indexes.monthindex_to_dateindex_count,
+            exit,
+        )?;
+
+        self.quarterindex.from_aligned(
+            starting_indexes.quarterindex,
+            &self.monthindex,
+            &indexes.quarterindex_to_first_monthindex,
+            &indexes.quarterindex_to_monthindex_count,
+            exit,
+        )?;
+
+        self.yearindex.from_aligned(
+            starting_indexes.yearindex,
+            &self.monthindex,
+            &indexes.yearindex_to_first_monthindex,
+            &indexes.yearindex_to_monthindex_count,
+            exit,
+        )?;
+
+        self.decadeindex.from_aligned(
+            starting_indexes.decadeindex,
+            &self.yearindex,
+            &indexes.decadeindex_to_first_yearindex,
+            &indexes.decadeindex_to_yearindex_count,
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            vec![&self.dateindex as &dyn AnyCollectableVec],
+            self.dateindex_extra.vecs(),
+            self.weekindex.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.yearindex.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .concat()
+    }
+}

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

@@ -0,0 +1,222 @@
+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::{AnyCollectableVec, AnyIterableVec, Compressed, EagerVec, Result, Version};
+
+use crate::storage::{Indexes, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromHeight<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub height: Option<EagerVec<Height, T>>,
+    pub height_extra: ComputedVecBuilder<Height, T>,
+    pub dateindex: ComputedVecBuilder<DateIndex, T>,
+    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
+    pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
+    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
+    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    pub yearindex: ComputedVecBuilder<YearIndex, T>,
+    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromHeight<T>
+where
+    T: ComputedType + Ord + From<f64>,
+    f64: From<T>,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let version = VERSION + version;
+
+        let height = compute_source.then(|| {
+            EagerVec::forced_import(&path.join(format!("height_to_{name}")), version, compressed)
+                .unwrap()
+        });
+
+        let height_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version,
+            compressed,
+            options.copy_self_extra(),
+        )?;
+
+        let dateindex =
+            ComputedVecBuilder::forced_import(path, name, version, compressed, options)?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            height,
+            height_extra,
+            dateindex,
+            weekindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            difficultyepoch: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>,
+    {
+        compute(
+            self.height.as_mut().unwrap(),
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        let height: Option<&EagerVec<Height, T>> = None;
+        self.compute_rest(indexes, starting_indexes, exit, height)?;
+
+        Ok(())
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        height: Option<&impl AnyIterableVec<Height, T>>,
+    ) -> color_eyre::Result<()> {
+        if let Some(height) = height {
+            self.height_extra
+                .extend(starting_indexes.height, height, exit)?;
+
+            self.dateindex.compute(
+                starting_indexes.dateindex,
+                height,
+                &indexes.dateindex_to_first_height,
+                &indexes.dateindex_to_height_count,
+                exit,
+            )?;
+
+            self.difficultyepoch.compute(
+                starting_indexes.difficultyepoch,
+                height,
+                &indexes.difficultyepoch_to_first_height,
+                &indexes.difficultyepoch_to_height_count,
+                exit,
+            )?;
+        } else {
+            let height = self.height.as_ref().unwrap();
+
+            self.height_extra
+                .extend(starting_indexes.height, height, exit)?;
+
+            self.dateindex.compute(
+                starting_indexes.dateindex,
+                height,
+                &indexes.dateindex_to_first_height,
+                &indexes.dateindex_to_height_count,
+                exit,
+            )?;
+
+            self.difficultyepoch.compute(
+                starting_indexes.difficultyepoch,
+                height,
+                &indexes.difficultyepoch_to_first_height,
+                &indexes.difficultyepoch_to_height_count,
+                exit,
+            )?;
+        }
+
+        self.weekindex.from_aligned(
+            starting_indexes.weekindex,
+            &self.dateindex,
+            &indexes.weekindex_to_first_dateindex,
+            &indexes.weekindex_to_dateindex_count,
+            exit,
+        )?;
+
+        self.monthindex.from_aligned(
+            starting_indexes.monthindex,
+            &self.dateindex,
+            &indexes.monthindex_to_first_dateindex,
+            &indexes.monthindex_to_dateindex_count,
+            exit,
+        )?;
+
+        self.quarterindex.from_aligned(
+            starting_indexes.quarterindex,
+            &self.monthindex,
+            &indexes.quarterindex_to_first_monthindex,
+            &indexes.quarterindex_to_monthindex_count,
+            exit,
+        )?;
+
+        self.yearindex.from_aligned(
+            starting_indexes.yearindex,
+            &self.monthindex,
+            &indexes.yearindex_to_first_monthindex,
+            &indexes.yearindex_to_monthindex_count,
+            exit,
+        )?;
+
+        self.decadeindex.from_aligned(
+            starting_indexes.decadeindex,
+            &self.yearindex,
+            &indexes.decadeindex_to_first_yearindex,
+            &indexes.decadeindex_to_yearindex_count,
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.height
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
+            self.height_extra.vecs(),
+            self.dateindex.vecs(),
+            self.weekindex.vecs(),
+            self.difficultyepoch.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.yearindex.vecs(),
+            // self.halvingepoch.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .concat()
+    }
+}

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

@@ -0,0 +1,98 @@
+use std::path::Path;
+
+use brk_core::{DifficultyEpoch, Height};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, Compressed, EagerVec, Result, Version};
+
+use crate::storage::{Indexes, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromHeightStrict<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub height: EagerVec<Height, T>,
+    pub height_extra: ComputedVecBuilder<Height, T>,
+    pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
+    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+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 version = VERSION + version;
+
+        let height =
+            EagerVec::forced_import(&path.join(format!("height_to_{name}")), version, compressed)?;
+
+        let height_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version,
+            compressed,
+            options.copy_self_extra(),
+        )?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            height,
+            height_extra,
+            difficultyepoch: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
+        })
+    }
+
+    pub fn compute<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>,
+    {
+        compute(&mut self.height, indexer, indexes, starting_indexes, exit)?;
+
+        self.height_extra
+            .extend(starting_indexes.height, &self.height, exit)?;
+
+        self.difficultyepoch.compute(
+            starting_indexes.difficultyepoch,
+            &self.height,
+            &indexes.difficultyepoch_to_first_height,
+            &indexes.difficultyepoch_to_height_count,
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            vec![&self.height as &dyn AnyCollectableVec],
+            self.height_extra.vecs(),
+            self.difficultyepoch.vecs(),
+            // self.halvingepoch.vecs(),
+        ]
+        .concat()
+    }
+}

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

@@ -0,0 +1,222 @@
+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::{
+    AnyCollectableVec, CollectableVec, Compressed, EagerVec, Result, StoredVec, Version,
+};
+
+use crate::storage::{Indexes, indexes};
+
+use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedVecsFromTxindex<T>
+where
+    T: ComputedType + PartialOrd,
+{
+    pub txindex: Option<EagerVec<TxIndex, T>>,
+    pub height: ComputedVecBuilder<Height, T>,
+    pub dateindex: ComputedVecBuilder<DateIndex, T>,
+    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
+    pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
+    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
+    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    pub yearindex: ComputedVecBuilder<YearIndex, T>,
+    // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
+}
+
+const VERSION: Version = Version::ZERO;
+
+impl<T> ComputedVecsFromTxindex<T>
+where
+    T: ComputedType + Ord + From<f64>,
+    f64: From<T>,
+{
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+    ) -> color_eyre::Result<Self> {
+        let version = VERSION + version;
+
+        let txindex = compute_source.then(|| {
+            EagerVec::forced_import(
+                &path.join(format!("txindex_to_{name}")),
+                version,
+                compressed,
+            )
+            .unwrap()
+        });
+
+        let height = ComputedVecBuilder::forced_import(path, name, version, compressed, options)?;
+
+        let options = options.remove_percentiles();
+
+        Ok(Self {
+            txindex,
+            height,
+            dateindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            weekindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            difficultyepoch: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+        })
+    }
+
+    #[allow(unused)]
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(
+            &mut EagerVec<TxIndex, T>,
+            &Indexer,
+            &indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(
+            self.txindex.as_mut().unwrap(),
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        let txindex: Option<&StoredVec<TxIndex, T>> = None;
+        self.compute_rest(indexer, indexes, starting_indexes, exit, txindex)?;
+
+        Ok(())
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        txindex: Option<&impl CollectableVec<TxIndex, T>>,
+    ) -> color_eyre::Result<()> {
+        if let Some(txindex) = txindex {
+            self.height.compute(
+                starting_indexes.height,
+                txindex,
+                &indexer.vecs().height_to_first_txindex,
+                &indexes.height_to_txindex_count,
+                exit,
+            )?;
+        } else {
+            let txindex = self.txindex.as_ref().unwrap();
+
+            self.height.compute(
+                starting_indexes.height,
+                txindex,
+                &indexer.vecs().height_to_first_txindex,
+                &indexes.height_to_txindex_count,
+                exit,
+            )?;
+        }
+
+        self.dateindex.from_aligned(
+            starting_indexes.dateindex,
+            &self.height,
+            &indexes.dateindex_to_first_height,
+            &indexes.dateindex_to_height_count,
+            exit,
+        )?;
+
+        self.weekindex.from_aligned(
+            starting_indexes.weekindex,
+            &self.dateindex,
+            &indexes.weekindex_to_first_dateindex,
+            &indexes.weekindex_to_dateindex_count,
+            exit,
+        )?;
+
+        self.monthindex.from_aligned(
+            starting_indexes.monthindex,
+            &self.dateindex,
+            &indexes.monthindex_to_first_dateindex,
+            &indexes.monthindex_to_dateindex_count,
+            exit,
+        )?;
+
+        self.quarterindex.from_aligned(
+            starting_indexes.quarterindex,
+            &self.monthindex,
+            &indexes.quarterindex_to_first_monthindex,
+            &indexes.quarterindex_to_monthindex_count,
+            exit,
+        )?;
+
+        self.yearindex.from_aligned(
+            starting_indexes.yearindex,
+            &self.monthindex,
+            &indexes.yearindex_to_first_monthindex,
+            &indexes.yearindex_to_monthindex_count,
+            exit,
+        )?;
+
+        self.decadeindex.from_aligned(
+            starting_indexes.decadeindex,
+            &self.yearindex,
+            &indexes.decadeindex_to_first_yearindex,
+            &indexes.decadeindex_to_yearindex_count,
+            exit,
+        )?;
+
+        self.difficultyepoch.from_aligned(
+            starting_indexes.difficultyepoch,
+            &self.height,
+            &indexes.difficultyepoch_to_first_height,
+            &indexes.difficultyepoch_to_height_count,
+            exit,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.txindex
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
+            self.height.vecs(),
+            self.dateindex.vecs(),
+            self.weekindex.vecs(),
+            self.difficultyepoch.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.yearindex.vecs(),
+            // self.halvingepoch.vecs(),
+            self.decadeindex.vecs(),
+        ]
+        .concat()
+    }
+}

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

@@ -0,0 +1,17 @@
+mod builder;
+mod from_dateindex;
+mod from_height;
+mod from_height_strict;
+mod from_txindex;
+mod r#type;
+mod value_from_height;
+mod value_from_txindex;
+
+pub use builder::*;
+pub use from_dateindex::*;
+pub use from_height::*;
+pub use from_height_strict::*;
+pub use from_txindex::*;
+use r#type::*;
+pub use value_from_height::*;
+pub use value_from_txindex::*;

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

@@ -4,10 +4,10 @@ use brk_vec::StoredType;
 
 pub trait ComputedType
 where
-    Self: StoredType + From<usize> + Div<usize, Output = Self> + Add<Output = Self>,
+    Self: StoredType + From<usize> + Div<usize, Output = Self> + Add<Output = Self> + Ord,
 {
 }
 impl<T> ComputedType for T where
-    T: StoredType + From<usize> + Div<usize, Output = Self> + Add<Output = Self>
+    T: StoredType + From<usize> + Div<usize, Output = Self> + Add<Output = Self> + Ord
 {
 }

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

@@ -0,0 +1,175 @@
+use std::path::Path;
+
+use brk_core::{Bitcoin, Dollars, Height, Sats};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{
+    AnyCollectableVec, CollectableVec, Compressed, EagerVec, Result, StoredVec, Version,
+};
+
+use crate::storage::{
+    marketprice,
+    vecs::{Indexes, indexes},
+};
+
+use super::{ComputedVecsFromHeight, StorableVecGeneatorOptions};
+
+#[derive(Clone)]
+pub struct ComputedValueVecsFromHeight {
+    pub sats: ComputedVecsFromHeight<Sats>,
+    pub bitcoin: ComputedVecsFromHeight<Bitcoin>,
+    pub dollars: Option<ComputedVecsFromHeight<Dollars>>,
+}
+
+const VERSION: Version = Version::ONE;
+
+impl ComputedValueVecsFromHeight {
+    pub fn forced_import(
+        path: &Path,
+        name: &str,
+        compute_source: bool,
+        version: Version,
+        compressed: Compressed,
+        options: StorableVecGeneatorOptions,
+        compute_dollars: bool,
+    ) -> color_eyre::Result<Self> {
+        Ok(Self {
+            sats: ComputedVecsFromHeight::forced_import(
+                path,
+                name,
+                compute_source,
+                VERSION + version,
+                compressed,
+                options,
+            )?,
+            bitcoin: ComputedVecsFromHeight::forced_import(
+                path,
+                &format!("{name}_in_btc"),
+                true,
+                VERSION + version,
+                compressed,
+                options,
+            )?,
+            dollars: compute_dollars.then(|| {
+                ComputedVecsFromHeight::forced_import(
+                    path,
+                    &format!("{name}_in_usd"),
+                    true,
+                    VERSION + version,
+                    compressed,
+                    options,
+                )
+                .unwrap()
+            }),
+        })
+    }
+
+    pub fn compute_all<F>(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        marketprices: Option<&marketprice::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        mut compute: F,
+    ) -> color_eyre::Result<()>
+    where
+        F: FnMut(
+            &mut EagerVec<Height, Sats>,
+            &Indexer,
+            &indexes::Vecs,
+            &Indexes,
+            &Exit,
+        ) -> Result<()>,
+    {
+        compute(
+            self.sats.height.as_mut().unwrap(),
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+        )?;
+
+        let height: Option<&StoredVec<Height, Sats>> = None;
+        self.compute_rest(
+            indexer,
+            indexes,
+            marketprices,
+            starting_indexes,
+            exit,
+            height,
+        )?;
+
+        Ok(())
+    }
+
+    pub fn compute_rest(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        marketprices: Option<&marketprice::Vecs>,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+        height: Option<&impl CollectableVec<Height, Sats>>,
+    ) -> color_eyre::Result<()> {
+        if let Some(height) = height {
+            self.sats
+                .compute_rest(indexes, starting_indexes, exit, Some(height))?;
+
+            self.bitcoin.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_sats(starting_indexes.height, height, exit)
+                },
+            )?;
+        } else {
+            let height: Option<&StoredVec<Height, Sats>> = None;
+
+            self.sats
+                .compute_rest(indexes, starting_indexes, exit, height)?;
+
+            self.bitcoin.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_sats(
+                        starting_indexes.height,
+                        self.sats.height.as_ref().unwrap(),
+                        exit,
+                    )
+                },
+            )?;
+        }
+
+        let txindex = self.bitcoin.height.as_ref().unwrap();
+        let price = &marketprices.as_ref().unwrap().chainindexes_to_close.height;
+
+        if let Some(dollars) = self.dollars.as_mut() {
+            dollars.compute_all(
+                indexer,
+                indexes,
+                starting_indexes,
+                exit,
+                |v, _, _, starting_indexes, exit| {
+                    v.compute_from_bitcoin(starting_indexes.height, txindex, price, exit)
+                },
+            )?;
+        }
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.sats.vecs(),
+            self.bitcoin.vecs(),
+            self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
+        ]
+        .concat()
+    }
+}

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

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

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

@@ -0,0 +1,128 @@
+use std::{fs, path::Path};
+
+use brk_core::{DifficultyEpoch, HalvingEpoch, StoredF64};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, Compressed, Computation, VecIterator, Version};
+
+use super::{
+    Indexes,
+    grouped::{ComputedVecsFromDateindex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    indexes,
+};
+
+#[derive(Clone)]
+pub struct Vecs {
+    pub indexes_to_difficulty: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_difficultyepoch: ComputedVecsFromDateindex<DifficultyEpoch>,
+    pub indexes_to_halvingepoch: ComputedVecsFromDateindex<HalvingEpoch>,
+}
+
+impl Vecs {
+    pub fn forced_import(
+        path: &Path,
+        _computation: Computation,
+        compressed: Compressed,
+    ) -> color_eyre::Result<Self> {
+        fs::create_dir_all(path)?;
+
+        Ok(Self {
+            indexes_to_difficulty: ComputedVecsFromHeight::forced_import(
+                path,
+                "difficulty",
+                false,
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_difficultyepoch: ComputedVecsFromDateindex::forced_import(
+                path,
+                "difficultyepoch",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_halvingepoch: ComputedVecsFromDateindex::forced_import(
+                path,
+                "halvingepoch",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+        })
+    }
+
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.into_iter();
+        self.indexes_to_difficultyepoch.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, indexes, starting_indexes, exit| {
+                let mut height_count_iter = indexes.dateindex_to_height_count.into_iter();
+                vec.compute_transform(
+                    starting_indexes.dateindex,
+                    &indexes.dateindex_to_first_height,
+                    |(di, height, ..)| {
+                        (
+                            di,
+                            height_to_difficultyepoch_iter.unwrap_get_inner(
+                                height + (*height_count_iter.unwrap_get_inner(di) - 1),
+                            ),
+                        )
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        let mut height_to_halvingepoch_iter = indexes.height_to_halvingepoch.into_iter();
+        self.indexes_to_halvingepoch.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, indexes, starting_indexes, exit| {
+                let mut height_count_iter = indexes.dateindex_to_height_count.into_iter();
+                vec.compute_transform(
+                    starting_indexes.dateindex,
+                    &indexes.dateindex_to_first_height,
+                    |(di, height, ..)| {
+                        (
+                            di,
+                            height_to_halvingepoch_iter.unwrap_get_inner(
+                                height + (*height_count_iter.unwrap_get_inner(di) - 1),
+                            ),
+                        )
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_difficulty.compute_rest(
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&indexer.vecs().height_to_difficulty),
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.indexes_to_difficulty.vecs(),
+            self.indexes_to_difficultyepoch.vecs(),
+            self.indexes_to_halvingepoch.vecs(),
+        ]
+        .concat()
+    }
+}

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

@@ -3,41 +3,60 @@ use std::{fs, path::Path};
 use brk_exit::Exit;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
-use brk_vec::{AnyStorableVec, Compressed};
+use brk_vec::{AnyCollectableVec, Compressed, Computation};
 
-mod base;
-mod blocks;
-mod indexes;
-mod marketprice;
-mod stats;
-mod transactions;
+pub mod blocks;
+pub mod grouped;
+pub mod indexes;
+pub mod marketprice;
+pub mod mining;
+pub mod transactions;
 
-use base::*;
-use indexes::*;
+pub use indexes::Indexes;
 
 #[derive(Clone)]
 pub struct Vecs {
-    pub blocks: blocks::Vecs,
     pub indexes: indexes::Vecs,
+    pub blocks: blocks::Vecs,
+    pub mining: mining::Vecs,
     pub transactions: transactions::Vecs,
     pub marketprice: Option<marketprice::Vecs>,
 }
 
 impl Vecs {
-    pub fn import(path: &Path, fetch: bool, compressed: Compressed) -> color_eyre::Result<Self> {
+    pub fn import(
+        path: &Path,
+        indexer: &Indexer,
+        fetch: bool,
+        computation: Computation,
+        compressed: Compressed,
+    ) -> color_eyre::Result<Self> {
         fs::create_dir_all(path)?;
 
+        let indexes = indexes::Vecs::forced_import(path, indexer, computation, compressed)?;
+
+        let marketprice =
+            fetch.then(|| marketprice::Vecs::forced_import(path, computation, compressed).unwrap());
+
         Ok(Self {
-            blocks: blocks::Vecs::forced_import(path, compressed)?,
-            indexes: indexes::Vecs::forced_import(path, compressed)?,
-            transactions: transactions::Vecs::forced_import(path, compressed)?,
-            marketprice: fetch.then(|| marketprice::Vecs::forced_import(path, compressed).unwrap()),
+            blocks: blocks::Vecs::forced_import(path, computation, compressed)?,
+            mining: mining::Vecs::forced_import(path, computation, compressed)?,
+            transactions: transactions::Vecs::forced_import(
+                path,
+                indexer,
+                &indexes,
+                computation,
+                compressed,
+                marketprice.as_ref(),
+            )?,
+            indexes,
+            marketprice,
         })
     }
 
     pub fn compute(
         &mut self,
-        indexer: &mut Indexer,
+        indexer: &Indexer,
         starting_indexes: brk_indexer::Indexes,
         fetcher: Option<&mut Fetcher>,
         exit: &Exit,
@@ -45,32 +64,39 @@ impl Vecs {
         let starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
 
         self.blocks
-            .compute(indexer, &mut self.indexes, &starting_indexes, exit)?;
+            .compute(indexer, &self.indexes, &starting_indexes, exit)?;
 
-        self.transactions
-            .compute(indexer, &mut self.indexes, &starting_indexes, exit)?;
+        self.mining
+            .compute(indexer, &self.indexes, &starting_indexes, exit)?;
 
         if let Some(marketprice) = self.marketprice.as_mut() {
             marketprice.compute(
                 indexer,
-                &mut self.indexes,
+                &self.indexes,
                 &starting_indexes,
                 fetcher.unwrap(),
                 exit,
             )?;
         }
 
+        self.transactions.compute(
+            indexer,
+            &self.indexes,
+            &starting_indexes,
+            self.marketprice.as_ref(),
+            exit,
+        )?;
+
         Ok(())
     }
 
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         [
-            self.indexes.as_any_vecs(),
-            self.blocks.as_any_vecs(),
-            self.transactions.as_any_vecs(),
-            self.marketprice
-                .as_ref()
-                .map_or(vec![], |v| v.as_any_vecs()),
+            self.indexes.vecs(),
+            self.blocks.vecs(),
+            self.mining.vecs(),
+            self.transactions.vecs(),
+            self.marketprice.as_ref().map_or(vec![], |v| v.vecs()),
         ]
         .concat()
     }

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/stats/generic.rs

@@ -1,567 +0,0 @@
-use std::path::Path;
-
-use brk_exit::Exit;
-use brk_vec::{AnyStorableVec, Compressed, Result, StoredIndex, StoredType, Version};
-
-use crate::storage::vecs::base::StorableVec;
-
-use super::ComputedType;
-
-#[derive(Clone, Debug)]
-pub struct StorableVecBuilder<I, T>
-where
-    I: StoredIndex,
-    T: ComputedType,
-{
-    pub first: Option<StorableVec<I, T>>,
-    pub average: Option<StorableVec<I, T>>,
-    pub sum: Option<StorableVec<I, T>>,
-    pub max: Option<StorableVec<I, T>>,
-    pub _90p: Option<StorableVec<I, T>>,
-    pub _75p: Option<StorableVec<I, T>>,
-    pub median: Option<StorableVec<I, T>>,
-    pub _25p: Option<StorableVec<I, T>>,
-    pub _10p: Option<StorableVec<I, T>>,
-    pub min: Option<StorableVec<I, T>>,
-    pub last: Option<StorableVec<I, T>>,
-}
-
-impl<I, T> StorableVecBuilder<I, T>
-where
-    I: StoredIndex,
-    T: ComputedType,
-{
-    pub fn forced_import(
-        path: &Path,
-        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 prefix = |s: &str| path.with_file_name(format!("{key}_to_{s}_{name}"));
-        let suffix = |s: &str| path.with_file_name(format!("{key}_to_{name}_{s}"));
-
-        let s = Self {
-            first: options.first.then(|| {
-                StorableVec::forced_import(&prefix("first"), Version::from(1), compressed).unwrap()
-            }),
-            last: options.last.then(|| {
-                StorableVec::forced_import(
-                    &path.with_file_name(format!("{key}_to_{name}")),
-                    Version::from(1),
-                    compressed,
-                )
-                .unwrap()
-            }),
-            min: options.min.then(|| {
-                StorableVec::forced_import(&suffix("min"), Version::from(1), compressed).unwrap()
-            }),
-            max: options.max.then(|| {
-                StorableVec::forced_import(&suffix("max"), Version::from(1), compressed).unwrap()
-            }),
-            median: options.median.then(|| {
-                StorableVec::forced_import(&suffix("median"), Version::from(1), compressed).unwrap()
-            }),
-            average: options.average.then(|| {
-                StorableVec::forced_import(&suffix("average"), Version::from(1), compressed)
-                    .unwrap()
-            }),
-            sum: options.sum.then(|| {
-                StorableVec::forced_import(&suffix("sum"), Version::from(1), compressed).unwrap()
-            }),
-            _90p: options._90p.then(|| {
-                StorableVec::forced_import(&suffix("90p"), Version::from(1), compressed).unwrap()
-            }),
-            _75p: options._75p.then(|| {
-                StorableVec::forced_import(&suffix("75p"), Version::from(1), compressed).unwrap()
-            }),
-            _25p: options._25p.then(|| {
-                StorableVec::forced_import(&suffix("25p"), Version::from(1), compressed).unwrap()
-            }),
-            _10p: options._10p.then(|| {
-                StorableVec::forced_import(&suffix("10p"), Version::from(1), compressed).unwrap()
-            }),
-        };
-
-        Ok(s)
-    }
-
-    pub fn compute<I2>(
-        &mut self,
-        max_from: I,
-        source: &mut StorableVec<I2, T>,
-        first_indexes: &mut brk_vec::StorableVec<I, I2>,
-        last_indexes: &mut brk_vec::StorableVec<I, I2>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I2: StoredIndex + StoredType,
-        T: Ord + From<f64>,
-        f64: From<T>,
-    {
-        let index = self.starting_index(max_from);
-
-        first_indexes.iter_from(index, |(i, first_index)| {
-            let first_index = *first_index;
-            let last_index = *last_indexes.get(i).unwrap().unwrap();
-
-            if let Some(first) = self.first.as_mut() {
-                let v = source.get(first_index).unwrap().unwrap();
-                first.forced_push_at(index, v.clone(), exit)?;
-            }
-
-            if let Some(last) = self.last.as_mut() {
-                let v = source.get(last_index).unwrap().unwrap();
-                last.forced_push_at(index, v.clone(), exit)?;
-            }
-
-            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_sorted = self.max.is_some()
-                || self._90p.is_some()
-                || self._75p.is_some()
-                || self.median.is_some()
-                || self._25p.is_some()
-                || self._10p.is_some()
-                || self.min.is_some();
-            let needs_values = needs_sorted || needs_sum_or_average;
-
-            if needs_values {
-                let mut values =
-                    source.collect_range(Some(first_index as i64), Some(last_index as i64))?;
-
-                if needs_sorted {
-                    values.sort_unstable();
-
-                    if let Some(max) = self.max.as_mut() {
-                        max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
-                    }
-
-                    if let Some(_90p) = self._90p.as_mut() {
-                        _90p.forced_push_at(i, Self::get_percentile(&values, 0.90), exit)?;
-                    }
-
-                    if let Some(_75p) = self._75p.as_mut() {
-                        _75p.forced_push_at(i, Self::get_percentile(&values, 0.75), exit)?;
-                    }
-
-                    if let Some(median) = self.median.as_mut() {
-                        median.forced_push_at(i, Self::get_percentile(&values, 0.50), exit)?;
-                    }
-
-                    if let Some(_25p) = self._25p.as_mut() {
-                        _25p.forced_push_at(i, Self::get_percentile(&values, 0.25), exit)?;
-                    }
-
-                    if let Some(_10p) = self._10p.as_mut() {
-                        _10p.forced_push_at(i, Self::get_percentile(&values, 0.10), exit)?;
-                    }
-
-                    if let Some(min) = self.min.as_mut() {
-                        min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
-                    }
-                }
-
-                if needs_sum_or_average {
-                    let len = values.len();
-
-                    if let Some(average) = self.average.as_mut() {
-                        let len = len as f64;
-                        let total = values
-                            .iter()
-                            .map(|v| f64::from(v.clone()))
-                            .fold(0.0, |a, b| a + b);
-                        let avg = T::from(total / len);
-                        average.forced_push_at(i, avg, exit)?;
-                    }
-
-                    if let Some(sum_vec) = self.sum.as_mut() {
-                        let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
-                        sum_vec.forced_push_at(i, sum, exit)?;
-                    }
-                }
-            }
-
-            Ok(())
-        })?;
-
-        self.safe_flush(exit)?;
-
-        Ok(())
-    }
-
-    #[allow(clippy::wrong_self_convention)]
-    pub fn from_aligned<I2>(
-        &mut self,
-        max_from: I,
-        source: &mut StorableVecBuilder<I2, T>,
-        first_indexes: &mut brk_vec::StorableVec<I, I2>,
-        last_indexes: &mut brk_vec::StorableVec<I, I2>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I2: StoredIndex + StoredType,
-        T: Ord + From<f64>,
-        f64: From<T>,
-    {
-        if self._90p.is_some()
-            || self._75p.is_some()
-            || self.median.is_some()
-            || self._25p.is_some()
-            || self._10p.is_some()
-        {
-            panic!("unsupported");
-        }
-
-        let index = self.starting_index(max_from);
-
-        first_indexes.iter_from(index, |(i, first_index)| {
-            let first_index = *first_index;
-            let last_index = *last_indexes.get(i).unwrap().unwrap();
-
-            if let Some(first) = self.first.as_mut() {
-                let v = source
-                    .first
-                    .as_mut()
-                    .unwrap()
-                    .get(first_index)
-                    .unwrap()
-                    .cloned()
-                    .unwrap();
-                first.forced_push_at(index, v, exit)?;
-            }
-
-            if let Some(last) = self.last.as_mut() {
-                let v = source
-                    .last
-                    .as_mut()
-                    .unwrap()
-                    .get(last_index)
-                    .unwrap()
-                    .cloned()
-                    .unwrap();
-                last.forced_push_at(index, v, exit)?;
-            }
-
-            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_sorted = self.max.is_some() || self.min.is_some();
-            let needs_values = needs_sorted || needs_sum_or_average;
-
-            if needs_values {
-                if needs_sorted {
-                    if let Some(max) = self.max.as_mut() {
-                        let mut values = source
-                            .max
-                            .as_ref()
-                            .unwrap()
-                            .collect_range(first_index, last_index)?;
-                        values.sort_unstable();
-                        max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
-                    }
-
-                    if let Some(min) = self.min.as_mut() {
-                        let mut values = source
-                            .min
-                            .as_ref()
-                            .unwrap()
-                            .collect_range(first_index, last_index)?;
-                        values.sort_unstable();
-                        min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
-                    }
-                }
-
-                if needs_sum_or_average {
-                    if let Some(average) = self.average.as_mut() {
-                        let values = source
-                            .average
-                            .as_ref()
-                            .unwrap()
-                            .collect_range(first_index, last_index)?;
-                        let len = values.len() as f64;
-                        let total = values
-                            .into_iter()
-                            .map(|v| f64::from(v))
-                            .fold(0.0, |a, b| a + b);
-                        // TODO: Multiply by count then divide by total
-                        // Right now it's not 100% accurate as there could be more or less elements in the lower timeframe (28 days vs 31 days in a month for example)
-                        let avg = T::from(total / len);
-                        average.forced_push_at(i, avg, exit)?;
-                    }
-
-                    if let Some(sum_vec) = self.sum.as_mut() {
-                        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)?;
-                    }
-                }
-            }
-
-            Ok(())
-        })?;
-
-        self.safe_flush(exit)?;
-
-        Ok(())
-    }
-
-    fn get_percentile(sorted: &[T], percentile: f64) -> T {
-        let len = sorted.len();
-
-        if len == 0 {
-            panic!();
-        } else if len == 1 {
-            sorted[0].clone()
-        } else {
-            let index = (len - 1) as f64 * percentile;
-
-            let fract = index.fract();
-
-            if fract != 0.0 {
-                let left = sorted.get(index as usize).unwrap().clone();
-                let right = sorted.get(index.ceil() as usize).unwrap().clone();
-                left / 2 + right / 2
-            } else {
-                sorted.get(index as usize).unwrap().clone()
-            }
-        }
-    }
-
-    fn starting_index(&self, max_from: I) -> I {
-        max_from.min(I::from(
-            self.as_any_vecs()
-                .into_iter()
-                .map(|v| v.len())
-                .min()
-                .unwrap(),
-        ))
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStorableVec> {
-        let mut v: Vec<&dyn AnyStorableVec> = vec![];
-
-        if let Some(first) = self.first.as_ref() {
-            v.push(first.any_vec());
-        }
-        if let Some(last) = self.last.as_ref() {
-            v.push(last.any_vec());
-        }
-        if let Some(min) = self.min.as_ref() {
-            v.push(min.any_vec());
-        }
-        if let Some(max) = self.max.as_ref() {
-            v.push(max.any_vec());
-        }
-        if let Some(median) = self.median.as_ref() {
-            v.push(median.any_vec());
-        }
-        if let Some(average) = self.average.as_ref() {
-            v.push(average.any_vec());
-        }
-        if let Some(sum) = self.sum.as_ref() {
-            v.push(sum.any_vec());
-        }
-        if let Some(_90p) = self._90p.as_ref() {
-            v.push(_90p.any_vec());
-        }
-        if let Some(_75p) = self._75p.as_ref() {
-            v.push(_75p.any_vec());
-        }
-        if let Some(_25p) = self._25p.as_ref() {
-            v.push(_25p.any_vec());
-        }
-        if let Some(_10p) = self._10p.as_ref() {
-            v.push(_10p.any_vec());
-        }
-
-        v
-    }
-
-    pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {
-        if let Some(first) = self.first.as_mut() {
-            first.safe_flush(exit)?;
-        }
-        if let Some(last) = self.last.as_mut() {
-            last.safe_flush(exit)?;
-        }
-        if let Some(min) = self.min.as_mut() {
-            min.safe_flush(exit)?;
-        }
-        if let Some(max) = self.max.as_mut() {
-            max.safe_flush(exit)?;
-        }
-        if let Some(median) = self.median.as_mut() {
-            median.safe_flush(exit)?;
-        }
-        if let Some(average) = self.average.as_mut() {
-            average.safe_flush(exit)?;
-        }
-        if let Some(sum) = self.sum.as_mut() {
-            sum.safe_flush(exit)?;
-        }
-        if let Some(_90p) = self._90p.as_mut() {
-            _90p.safe_flush(exit)?;
-        }
-        if let Some(_75p) = self._75p.as_mut() {
-            _75p.safe_flush(exit)?;
-        }
-        if let Some(_25p) = self._25p.as_mut() {
-            _25p.safe_flush(exit)?;
-        }
-        if let Some(_10p) = self._10p.as_mut() {
-            _10p.safe_flush(exit)?;
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Default, Clone, Copy)]
-pub struct StorableVecGeneatorOptions {
-    average: bool,
-    sum: bool,
-    max: bool,
-    _90p: bool,
-    _75p: bool,
-    median: bool,
-    _25p: bool,
-    _10p: bool,
-    min: bool,
-    first: bool,
-    last: bool,
-}
-
-impl StorableVecGeneatorOptions {
-    pub fn add_first(mut self) -> Self {
-        self.first = true;
-        self
-    }
-
-    pub fn add_last(mut self) -> Self {
-        self.last = true;
-        self
-    }
-
-    pub fn add_min(mut self) -> Self {
-        self.min = true;
-        self
-    }
-
-    pub fn add_max(mut self) -> Self {
-        self.max = true;
-        self
-    }
-
-    pub fn add_median(mut self) -> Self {
-        self.median = true;
-        self
-    }
-
-    pub fn add_average(mut self) -> Self {
-        self.average = true;
-        self
-    }
-
-    pub fn add_sum(mut self) -> Self {
-        self.sum = true;
-        self
-    }
-
-    pub fn add_90p(mut self) -> Self {
-        self._90p = true;
-        self
-    }
-
-    pub fn add_75p(mut self) -> Self {
-        self._75p = true;
-        self
-    }
-
-    pub fn add_25p(mut self) -> Self {
-        self._25p = true;
-        self
-    }
-
-    pub fn add_10p(mut self) -> Self {
-        self._10p = true;
-        self
-    }
-
-    pub fn rm_min(mut self) -> Self {
-        self.min = false;
-        self
-    }
-
-    pub fn rm_max(mut self) -> Self {
-        self.max = false;
-        self
-    }
-
-    pub fn rm_median(mut self) -> Self {
-        self.median = false;
-        self
-    }
-
-    pub fn rm_average(mut self) -> Self {
-        self.average = false;
-        self
-    }
-
-    pub fn rm_sum(mut self) -> Self {
-        self.sum = false;
-        self
-    }
-
-    pub fn rm_90p(mut self) -> Self {
-        self._90p = false;
-        self
-    }
-
-    pub fn rm_75p(mut self) -> Self {
-        self._75p = false;
-        self
-    }
-
-    pub fn rm_25p(mut self) -> Self {
-        self._25p = false;
-        self
-    }
-
-    pub fn rm_10p(mut self) -> Self {
-        self._10p = false;
-        self
-    }
-
-    pub fn add_minmax(mut self) -> Self {
-        self.min = true;
-        self.max = true;
-        self
-    }
-
-    pub fn add_percentiles(mut self) -> Self {
-        self._90p = true;
-        self._75p = true;
-        self.median = true;
-        self._25p = true;
-        self._10p = true;
-        self
-    }
-
-    pub fn remove_percentiles(mut self) -> Self {
-        self._90p = false;
-        self._75p = false;
-        self.median = false;
-        self._25p = false;
-        self._10p = false;
-        self
-    }
-}

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

@@ -1,11 +0,0 @@
-mod from_date;
-mod from_height;
-mod from_height_strict;
-mod generic;
-mod stored_type;
-
-pub use from_date::*;
-pub use from_height::*;
-pub use from_height_strict::*;
-pub use generic::*;
-pub use stored_type::*;

crates/brk_core/Cargo.toml

@@ -16,8 +16,10 @@ log = { workspace = true }
 rapidhash = "1.4.0"
 rlimit = "0.10.2"
 serde = { workspace = true }
+serde_derive = { workspace = true }
 serde_bytes = "0.11.17"
 zerocopy = { workspace = true }
+zerocopy-derive = { workspace = true }
 
 [package.metadata.cargo-machete]
 ignored = ["serde_bytes"]

crates/brk_core/README.md

@@ -20,7 +20,7 @@
   <a href="https://deps.rs/crate/brk_core">
     <img src="https://deps.rs/crate/brk_core/latest/status.svg" alt="Dependency status">
   </a>
-  <a href="https://discord.gg/Cvrwpv3zEG">
+  <a href="https://discord.gg/HaR3wpH3nr">
     <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
   </a>
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_core/src/structs/_addressindex.rs

@@ -2,7 +2,7 @@ use std::ops::Add;
 
 use byteview::ByteView;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::Error;
 
@@ -21,9 +21,9 @@ use crate::Error;
     KnownLayout,
     Serialize,
 )]
-pub struct Addressindex(u32);
+pub struct AddressIndex(u32);
 
-impl Addressindex {
+impl AddressIndex {
     pub const BYTES: usize = size_of::<Self>();
 
     pub fn increment(&mut self) {
@@ -35,56 +35,56 @@ impl Addressindex {
     }
 }
 
-impl From<u32> for Addressindex {
+impl From<u32> for AddressIndex {
     fn from(value: u32) -> Self {
         Self(value)
     }
 }
 
-impl From<u64> for Addressindex {
+impl From<u64> for AddressIndex {
     fn from(value: u64) -> Self {
         Self(value as u32)
     }
 }
-impl From<Addressindex> for u64 {
-    fn from(value: Addressindex) -> Self {
+impl From<AddressIndex> for u64 {
+    fn from(value: AddressIndex) -> Self {
         value.0 as u64
     }
 }
 
-impl From<usize> for Addressindex {
+impl From<usize> for AddressIndex {
     fn from(value: usize) -> Self {
         Self(value as u32)
     }
 }
-impl From<Addressindex> for usize {
-    fn from(value: Addressindex) -> Self {
+impl From<AddressIndex> for usize {
+    fn from(value: AddressIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl TryFrom<ByteView> for Addressindex {
+impl TryFrom<ByteView> for AddressIndex {
     type Error = Error;
     fn try_from(value: ByteView) -> Result<Self, Self::Error> {
         Ok(Self::read_from_bytes(&value)?)
     }
 }
-impl From<Addressindex> for ByteView {
-    fn from(value: Addressindex) -> Self {
+impl From<AddressIndex> for ByteView {
+    fn from(value: AddressIndex) -> Self {
         Self::new(value.as_bytes())
     }
 }
 
-impl Add<usize> for Addressindex {
+impl Add<usize> for AddressIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(self.0 + rhs as u32)
     }
 }
 
-impl Add<Addressindex> for Addressindex {
+impl Add<AddressIndex> for AddressIndex {
     type Output = Self;
-    fn add(self, rhs: Addressindex) -> Self::Output {
+    fn add(self, rhs: AddressIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }

crates/brk_core/src/structs/_addressindexoutputindex.rs

@@ -0,0 +1,28 @@
+use byteview::ByteView;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::Error;
+
+use super::{AddressIndex, Outputindex};
+
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Immutable, IntoBytes, KnownLayout, FromBytes,
+)]
+#[repr(C)]
+pub struct AddressIndexOutputIndex {
+    addressindex: AddressIndex,
+    _padding: u32,
+    outputindex: Outputindex,
+}
+
+impl TryFrom<ByteView> for AddressIndexOutputIndex {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<AddressIndexOutputIndex> for ByteView {
+    fn from(value: AddressIndexOutputIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_core/src/structs/_addresstype.rs

@@ -0,0 +1,48 @@
+use serde::Serialize;
+use zerocopy_derive::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+
+use super::OutputType;
+
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    TryFromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+#[repr(u8)]
+pub enum AddressType {
+    P2PK65,
+    P2PK33,
+    P2PKH,
+    P2SH,
+    P2WPKH,
+    P2WSH,
+    P2TR,
+    P2A,
+}
+
+impl From<OutputType> for AddressType {
+    fn from(value: OutputType) -> Self {
+        match value {
+            OutputType::P2A => Self::P2A,
+            OutputType::P2PK33 => Self::P2PK33,
+            OutputType::P2PK65 => Self::P2PK65,
+            OutputType::P2PKH => Self::P2PKH,
+            OutputType::P2SH => Self::P2SH,
+            OutputType::P2TR => Self::P2TR,
+            OutputType::P2WPKH => Self::P2WPKH,
+            OutputType::P2WSH => Self::P2WSH,
+            OutputType::Empty | OutputType::OpReturn | OutputType::P2MS | OutputType::Unknown => {
+                unreachable!()
+            }
+        }
+    }
+}

crates/brk_core/src/structs/addressbytes.rs

@@ -8,44 +8,46 @@ use bitcoin::{
 };
 use derive_deref::{Deref, DerefMut};
 use serde::{Serialize, Serializer};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::Error;
 
-use super::Addresstype;
+use super::OutputType;
 
 #[derive(Debug, PartialEq, Eq)]
-pub enum Addressbytes {
-    P2PK65(P2PK65AddressBytes),
-    P2PK33(P2PK33AddressBytes),
-    P2PKH(P2PKHAddressBytes),
-    P2SH(P2SHAddressBytes),
-    P2WPKH(P2WPKHAddressBytes),
-    P2WSH(P2WSHAddressBytes),
-    P2TR(P2TRAddressBytes),
+pub enum AddressBytes {
+    P2PK65(P2PK65Bytes),
+    P2PK33(P2PK33Bytes),
+    P2PKH(P2PKHBytes),
+    P2SH(P2SHBytes),
+    P2WPKH(P2WPKHBytes),
+    P2WSH(P2WSHBytes),
+    P2TR(P2TRBytes),
+    P2A(P2ABytes),
 }
 
-impl Addressbytes {
+impl AddressBytes {
     pub fn as_slice(&self) -> &[u8] {
         match self {
-            Addressbytes::P2PK65(bytes) => &bytes[..],
-            Addressbytes::P2PK33(bytes) => &bytes[..],
-            Addressbytes::P2PKH(bytes) => &bytes[..],
-            Addressbytes::P2SH(bytes) => &bytes[..],
-            Addressbytes::P2WPKH(bytes) => &bytes[..],
-            Addressbytes::P2WSH(bytes) => &bytes[..],
-            Addressbytes::P2TR(bytes) => &bytes[..],
+            AddressBytes::P2PK65(bytes) => &bytes[..],
+            AddressBytes::P2PK33(bytes) => &bytes[..],
+            AddressBytes::P2PKH(bytes) => &bytes[..],
+            AddressBytes::P2SH(bytes) => &bytes[..],
+            AddressBytes::P2WPKH(bytes) => &bytes[..],
+            AddressBytes::P2WSH(bytes) => &bytes[..],
+            AddressBytes::P2TR(bytes) => &bytes[..],
+            AddressBytes::P2A(bytes) => &bytes[..],
         }
     }
 }
 
-impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
+impl TryFrom<(&ScriptBuf, OutputType)> for AddressBytes {
     type Error = Error;
-    fn try_from(tuple: (&ScriptBuf, Addresstype)) -> Result<Self, Self::Error> {
-        let (script, addresstype) = tuple;
+    fn try_from(tuple: (&ScriptBuf, OutputType)) -> Result<Self, Self::Error> {
+        let (script, outputtype) = tuple;
 
-        match addresstype {
-            Addresstype::P2PK65 => {
+        match outputtype {
+            OutputType::P2PK65 => {
                 let bytes = script.as_bytes();
                 let bytes = match bytes.len() {
                     67 => &bytes[1..66],
@@ -54,9 +56,9 @@ impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
                         return Err(Error::WrongLength);
                     }
                 };
-                Ok(Self::P2PK65(P2PK65AddressBytes(U8x65::from(bytes))))
+                Ok(Self::P2PK65(P2PK65Bytes(U8x65::from(bytes))))
             }
-            Addresstype::P2PK33 => {
+            OutputType::P2PK33 => {
                 let bytes = script.as_bytes();
                 let bytes = match bytes.len() {
                     35 => &bytes[1..34],
@@ -65,47 +67,50 @@ impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
                         return Err(Error::WrongLength);
                     }
                 };
-                Ok(Self::P2PK33(P2PK33AddressBytes(U8x33::from(bytes))))
+                Ok(Self::P2PK33(P2PK33Bytes(U8x33::from(bytes))))
             }
-            Addresstype::P2PKH => {
+            OutputType::P2PKH => {
                 let bytes = &script.as_bytes()[3..23];
-                Ok(Self::P2PKH(P2PKHAddressBytes(U8x20::from(bytes))))
+                Ok(Self::P2PKH(P2PKHBytes(U8x20::from(bytes))))
             }
-            Addresstype::P2SH => {
+            OutputType::P2SH => {
                 let bytes = &script.as_bytes()[2..22];
-                Ok(Self::P2SH(P2SHAddressBytes(U8x20::from(bytes))))
+                Ok(Self::P2SH(P2SHBytes(U8x20::from(bytes))))
             }
-            Addresstype::P2WPKH => {
+            OutputType::P2WPKH => {
                 let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2WPKH(P2WPKHAddressBytes(U8x20::from(bytes))))
+                Ok(Self::P2WPKH(P2WPKHBytes(U8x20::from(bytes))))
             }
-            Addresstype::P2WSH => {
+            OutputType::P2WSH => {
                 let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2WSH(P2WSHAddressBytes(U8x32::from(bytes))))
+                Ok(Self::P2WSH(P2WSHBytes(U8x32::from(bytes))))
             }
-            Addresstype::P2TR => {
+            OutputType::P2TR => {
                 let bytes = &script.as_bytes()[2..];
-                Ok(Self::P2TR(P2TRAddressBytes(U8x32::from(bytes))))
+                Ok(Self::P2TR(P2TRBytes(U8x32::from(bytes))))
             }
-            Addresstype::Multisig => Err(Error::WrongAddressType),
-            Addresstype::PushOnly => Err(Error::WrongAddressType),
-            Addresstype::Unknown => Err(Error::WrongAddressType),
-            Addresstype::Empty => Err(Error::WrongAddressType),
-            Addresstype::OpReturn => Err(Error::WrongAddressType),
+            OutputType::P2A => {
+                let bytes = &script.as_bytes()[2..];
+                Ok(Self::P2A(P2ABytes(U8x2::from(bytes))))
+            }
+            OutputType::P2MS => Err(Error::WrongAddressType),
+            OutputType::Unknown => Err(Error::WrongAddressType),
+            OutputType::Empty => Err(Error::WrongAddressType),
+            OutputType::OpReturn => Err(Error::WrongAddressType),
         }
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2PK65AddressBytes(U8x65);
+pub struct P2PK65Bytes(U8x65);
 
-impl fmt::Display for P2PK65AddressBytes {
+impl fmt::Display for P2PK65Bytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.to_hex_string(Case::Lower))
     }
 }
 
-impl Serialize for P2PK65AddressBytes {
+impl Serialize for P2PK65Bytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -114,22 +119,22 @@ impl Serialize for P2PK65AddressBytes {
     }
 }
 
-impl From<P2PK65AddressBytes> for Addressbytes {
-    fn from(value: P2PK65AddressBytes) -> Self {
+impl From<P2PK65Bytes> for AddressBytes {
+    fn from(value: P2PK65Bytes) -> Self {
         Self::P2PK65(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2PK33AddressBytes(U8x33);
+pub struct P2PK33Bytes(U8x33);
 
-impl fmt::Display for P2PK33AddressBytes {
+impl fmt::Display for P2PK33Bytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.to_hex_string(Case::Lower))
     }
 }
 
-impl Serialize for P2PK33AddressBytes {
+impl Serialize for P2PK33Bytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -138,16 +143,16 @@ impl Serialize for P2PK33AddressBytes {
     }
 }
 
-impl From<P2PK33AddressBytes> for Addressbytes {
-    fn from(value: P2PK33AddressBytes) -> Self {
+impl From<P2PK33Bytes> for AddressBytes {
+    fn from(value: P2PK33Bytes) -> Self {
         Self::P2PK33(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2PKHAddressBytes(U8x20);
+pub struct P2PKHBytes(U8x20);
 
-impl fmt::Display for P2PKHAddressBytes {
+impl fmt::Display for P2PKHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new()
             .push_opcode(opcodes::all::OP_DUP)
@@ -161,7 +166,7 @@ impl fmt::Display for P2PKHAddressBytes {
     }
 }
 
-impl Serialize for P2PKHAddressBytes {
+impl Serialize for P2PKHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -170,16 +175,16 @@ impl Serialize for P2PKHAddressBytes {
     }
 }
 
-impl From<P2PKHAddressBytes> for Addressbytes {
-    fn from(value: P2PKHAddressBytes) -> Self {
+impl From<P2PKHBytes> for AddressBytes {
+    fn from(value: P2PKHBytes) -> Self {
         Self::P2PKH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2SHAddressBytes(U8x20);
+pub struct P2SHBytes(U8x20);
 
-impl fmt::Display for P2SHAddressBytes {
+impl fmt::Display for P2SHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new()
             .push_opcode(opcodes::all::OP_HASH160)
@@ -191,7 +196,7 @@ impl fmt::Display for P2SHAddressBytes {
     }
 }
 
-impl Serialize for P2SHAddressBytes {
+impl Serialize for P2SHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -200,16 +205,16 @@ impl Serialize for P2SHAddressBytes {
     }
 }
 
-impl From<P2SHAddressBytes> for Addressbytes {
-    fn from(value: P2SHAddressBytes) -> Self {
+impl From<P2SHBytes> for AddressBytes {
+    fn from(value: P2SHBytes) -> Self {
         Self::P2SH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2WPKHAddressBytes(U8x20);
+pub struct P2WPKHBytes(U8x20);
 
-impl fmt::Display for P2WPKHAddressBytes {
+impl fmt::Display for P2WPKHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(0).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
@@ -217,7 +222,7 @@ impl fmt::Display for P2WPKHAddressBytes {
     }
 }
 
-impl Serialize for P2WPKHAddressBytes {
+impl Serialize for P2WPKHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -226,16 +231,16 @@ impl Serialize for P2WPKHAddressBytes {
     }
 }
 
-impl From<P2WPKHAddressBytes> for Addressbytes {
-    fn from(value: P2WPKHAddressBytes) -> Self {
+impl From<P2WPKHBytes> for AddressBytes {
+    fn from(value: P2WPKHBytes) -> Self {
         Self::P2WPKH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2WSHAddressBytes(U8x32);
+pub struct P2WSHBytes(U8x32);
 
-impl fmt::Display for P2WSHAddressBytes {
+impl fmt::Display for P2WSHBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(0).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
@@ -243,7 +248,7 @@ impl fmt::Display for P2WSHAddressBytes {
     }
 }
 
-impl Serialize for P2WSHAddressBytes {
+impl Serialize for P2WSHBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -252,16 +257,16 @@ impl Serialize for P2WSHAddressBytes {
     }
 }
 
-impl From<P2WSHAddressBytes> for Addressbytes {
-    fn from(value: P2WSHAddressBytes) -> Self {
+impl From<P2WSHBytes> for AddressBytes {
+    fn from(value: P2WSHBytes) -> Self {
         Self::P2WSH(value)
     }
 }
 
 #[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
-pub struct P2TRAddressBytes(U8x32);
+pub struct P2TRBytes(U8x32);
 
-impl fmt::Display for P2TRAddressBytes {
+impl fmt::Display for P2TRBytes {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let script = Builder::new().push_int(1).push_slice(*self.0).into_script();
         let address = Address::from_script(&script, Network::Bitcoin).unwrap();
@@ -269,7 +274,7 @@ impl fmt::Display for P2TRAddressBytes {
     }
 }
 
-impl Serialize for P2TRAddressBytes {
+impl Serialize for P2TRBytes {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -278,12 +283,60 @@ impl Serialize for P2TRAddressBytes {
     }
 }
 
-impl From<P2TRAddressBytes> for Addressbytes {
-    fn from(value: P2TRAddressBytes) -> Self {
+impl From<P2TRBytes> for AddressBytes {
+    fn from(value: P2TRBytes) -> Self {
         Self::P2TR(value)
     }
 }
 
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
+pub struct P2ABytes(U8x2);
+
+impl fmt::Display for P2ABytes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let script = Builder::new().push_int(1).push_slice(*self.0).into_script();
+        let address = Address::from_script(&script, Network::Bitcoin).unwrap();
+        write!(f, "{}", address)
+    }
+}
+
+impl Serialize for P2ABytes {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_str(&self.to_string())
+    }
+}
+
+impl From<P2ABytes> for AddressBytes {
+    fn from(value: P2ABytes) -> Self {
+        Self::P2A(value)
+    }
+}
+
+#[derive(
+    Debug,
+    Clone,
+    Deref,
+    DerefMut,
+    PartialEq,
+    Eq,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    FromBytes,
+    Serialize,
+)]
+pub struct U8x2([u8; 2]);
+impl From<&[u8]> for U8x2 {
+    fn from(slice: &[u8]) -> Self {
+        let mut arr = [0; 2];
+        arr.copy_from_slice(slice);
+        Self(arr)
+    }
+}
+
 #[derive(
     Debug,
     Clone,

crates/brk_core/src/structs/addressbyteshash.rs

@@ -0,0 +1,61 @@
+use std::hash::Hasher;
+
+use byteview::ByteView;
+use derive_deref::Deref;
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::Error;
+
+use super::{AddressBytes, OutputType};
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
+pub struct AddressBytesHash([u8; 8]);
+
+impl From<(&AddressBytes, OutputType)> for AddressBytesHash {
+    fn from((address_bytes, outputtype): (&AddressBytes, OutputType)) -> Self {
+        let mut hasher = rapidhash::RapidHasher::default();
+        hasher.write(address_bytes.as_slice());
+        let mut slice = hasher.finish().to_le_bytes();
+        slice[0] = slice[0].wrapping_add(outputtype as u8);
+        Self(slice)
+    }
+}
+
+impl From<[u8; 8]> for AddressBytesHash {
+    fn from(value: [u8; 8]) -> Self {
+        Self(value)
+    }
+}
+
+impl TryFrom<ByteView> for AddressBytesHash {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+
+impl From<&AddressBytesHash> for ByteView {
+    fn from(value: &AddressBytesHash) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+
+impl From<AddressBytesHash> for ByteView {
+    fn from(value: AddressBytesHash) -> Self {
+        Self::from(&value)
+    }
+}

crates/brk_core/src/structs/addressindextxoutindex.rs

@@ -1,26 +0,0 @@
-use byteview::ByteView;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use crate::Error;
-
-use super::{Addressindex, Txoutindex};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Immutable, IntoBytes, KnownLayout, FromBytes)]
-#[repr(C)]
-pub struct AddressindexTxoutindex {
-    addressindex: Addressindex,
-    _padding: u32,
-    txoutindex: Txoutindex,
-}
-
-impl TryFrom<ByteView> for AddressindexTxoutindex {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<AddressindexTxoutindex> for ByteView {
-    fn from(value: AddressindexTxoutindex) -> Self {
-        Self::new(value.as_bytes())
-    }
-}

crates/brk_core/src/structs/addresstypeindex.rs

@@ -1,560 +0,0 @@
-use std::ops::Add;
-
-use derive_deref::{Deref, DerefMut};
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Addresstypeindex(u32);
-
-impl Addresstypeindex {
-    pub fn increment(&mut self) {
-        self.0 += 1;
-    }
-
-    pub fn incremented(self) -> Self {
-        Self(self.0 + 1)
-    }
-
-    pub fn copy_then_increment(&mut self) -> Self {
-        let i = *self;
-        self.increment();
-        i
-    }
-}
-
-impl From<u32> for Addresstypeindex {
-    fn from(value: u32) -> Self {
-        Self(value)
-    }
-}
-
-impl From<u64> for Addresstypeindex {
-    fn from(value: u64) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Addresstypeindex> for u64 {
-    fn from(value: Addresstypeindex) -> Self {
-        value.0 as u64
-    }
-}
-
-impl From<usize> for Addresstypeindex {
-    fn from(value: usize) -> Self {
-        Self(value as u32)
-    }
-}
-impl From<Addresstypeindex> for usize {
-    fn from(value: Addresstypeindex) -> Self {
-        value.0 as usize
-    }
-}
-
-impl Add<usize> for Addresstypeindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(self.0 + rhs as u32)
-    }
-}
-
-impl Add<Addresstypeindex> for Addresstypeindex {
-    type Output = Self;
-    fn add(self, rhs: Addresstypeindex) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Emptyindex(Addresstypeindex);
-impl From<Addresstypeindex> for Emptyindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Emptyindex> for usize {
-    fn from(value: Emptyindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Emptyindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Emptyindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Multisigindex(Addresstypeindex);
-impl From<Addresstypeindex> for Multisigindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Multisigindex> for usize {
-    fn from(value: Multisigindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Multisigindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Multisigindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Opreturnindex(Addresstypeindex);
-impl From<Addresstypeindex> for Opreturnindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Opreturnindex> for usize {
-    fn from(value: Opreturnindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Opreturnindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Opreturnindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Pushonlyindex(Addresstypeindex);
-impl From<Addresstypeindex> for Pushonlyindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Pushonlyindex> for usize {
-    fn from(value: Pushonlyindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Pushonlyindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Pushonlyindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct Unknownindex(Addresstypeindex);
-impl From<Addresstypeindex> for Unknownindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<Unknownindex> for usize {
-    fn from(value: Unknownindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for Unknownindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for Unknownindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2PK33index(Addresstypeindex);
-impl From<Addresstypeindex> for P2PK33index {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2PK33index> for usize {
-    fn from(value: P2PK33index) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2PK33index {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2PK33index {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2PK65index(Addresstypeindex);
-impl From<Addresstypeindex> for P2PK65index {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2PK65index> for usize {
-    fn from(value: P2PK65index) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2PK65index {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2PK65index {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2PKHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2PKHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2PKHindex> for usize {
-    fn from(value: P2PKHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2PKHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2PKHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2SHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2SHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2SHindex> for usize {
-    fn from(value: P2SHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2SHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2SHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2TRindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2TRindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2TRindex> for usize {
-    fn from(value: P2TRindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2TRindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2TRindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2WPKHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2WPKHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2WPKHindex> for usize {
-    fn from(value: P2WPKHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2WPKHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2WPKHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}
-
-#[derive(
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Clone,
-    Copy,
-    Deref,
-    DerefMut,
-    Default,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-    Serialize,
-)]
-pub struct P2WSHindex(Addresstypeindex);
-impl From<Addresstypeindex> for P2WSHindex {
-    fn from(value: Addresstypeindex) -> Self {
-        Self(value)
-    }
-}
-impl From<P2WSHindex> for usize {
-    fn from(value: P2WSHindex) -> Self {
-        Self::from(*value)
-    }
-}
-impl From<usize> for P2WSHindex {
-    fn from(value: usize) -> Self {
-        Self(Addresstypeindex::from(value))
-    }
-}
-impl Add<usize> for P2WSHindex {
-    type Output = Self;
-    fn add(self, rhs: usize) -> Self::Output {
-        Self(*self + rhs)
-    }
-}

crates/brk_core/src/structs/bitcoin.rs

@@ -1,20 +1,49 @@
-use std::ops::Mul;
+use std::ops::{Add, Div, Mul};
+
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::Sats;
 
-#[derive(Debug, Default, Clone, Copy)]
+#[derive(
+    Debug,
+    Default,
+    Clone,
+    Copy,
+    PartialEq,
+    PartialOrd,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
 pub struct Bitcoin(f64);
 
+impl Add for Bitcoin {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::from(Sats::from(self) + Sats::from(rhs))
+    }
+}
+
 impl Mul for Bitcoin {
     type Output = Self;
     fn mul(self, rhs: Self) -> Self::Output {
-        Self(self.0 * rhs.0)
+        Self::from(Sats::from(self) * Sats::from(rhs))
+    }
+}
+
+impl Div<usize> for Bitcoin {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self::from(Sats::from(self) / rhs)
     }
 }
 
 impl From<Sats> for Bitcoin {
     fn from(value: Sats) -> Self {
-        Self(u64::from(value) as f64 / (u64::from(Sats::ONE_BTC) as f64))
+        Self(f64::from(value) / (f64::from(Sats::ONE_BTC)))
     }
 }
 
@@ -29,3 +58,18 @@ impl From<Bitcoin> for f64 {
         value.0
     }
 }
+
+impl From<usize> for Bitcoin {
+    fn from(value: usize) -> Self {
+        Self(value as f64)
+    }
+}
+
+impl Eq for Bitcoin {}
+
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for Bitcoin {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.partial_cmp(&other.0).unwrap()
+    }
+}

crates/brk_core/src/structs/blockhash.rs

@@ -4,7 +4,7 @@ use bitcoin::hashes::Hash;
 use bitcoincore_rpc::{Client, RpcApi};
 use derive_deref::Deref;
 use serde::{Serialize, Serializer};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::Height;
 

crates/brk_core/src/structs/blockhashprefix.rs

@@ -0,0 +1,55 @@
+use byteview::ByteView;
+use derive_deref::Deref;
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{Error, copy_first_8bytes};
+
+use super::BlockHash;
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
+pub struct BlockHashPrefix([u8; 8]);
+
+impl From<BlockHash> for BlockHashPrefix {
+    fn from(value: BlockHash) -> Self {
+        Self::from(&value)
+    }
+}
+
+impl From<&BlockHash> for BlockHashPrefix {
+    fn from(value: &BlockHash) -> Self {
+        Self(copy_first_8bytes(&value[..]).unwrap())
+    }
+}
+
+impl TryFrom<ByteView> for BlockHashPrefix {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+
+impl From<&BlockHashPrefix> for ByteView {
+    fn from(value: &BlockHashPrefix) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+
+impl From<BlockHashPrefix> for ByteView {
+    fn from(value: BlockHashPrefix) -> Self {
+        Self::from(&value)
+    }
+}

crates/brk_core/src/structs/cents.rs

@@ -1,5 +1,7 @@
+use std::ops::{Add, Div};
+
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::Dollars;
 
@@ -22,7 +24,7 @@ pub struct Cents(u64);
 
 impl From<Dollars> for Cents {
     fn from(value: Dollars) -> Self {
-        Self((*value * 100.0).floor() as u64)
+        Self((*value * 100.0).round() as u64)
     }
 }
 
@@ -31,3 +33,29 @@ impl From<Cents> for f64 {
         value.0 as f64
     }
 }
+
+impl From<u64> for Cents {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Cents> for u64 {
+    fn from(value: Cents) -> Self {
+        value.0
+    }
+}
+
+impl Add for Cents {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Div<usize> for Cents {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self(self.0 / rhs as u64)
+    }
+}

crates/brk_core/src/structs/compressed.rs

@@ -1,156 +0,0 @@
-use std::hash::Hasher;
-
-use byteview::ByteView;
-use derive_deref::Deref;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
-
-use crate::Error;
-
-use super::{Addressbytes, Addresstype, BlockHash, Txid};
-
-#[derive(
-    Debug,
-    Deref,
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-)]
-pub struct AddressHash([u8; 8]);
-impl From<(&Addressbytes, Addresstype)> for AddressHash {
-    fn from((addressbytes, addresstype): (&Addressbytes, Addresstype)) -> Self {
-        let mut hasher = rapidhash::RapidHasher::default();
-        hasher.write(addressbytes.as_slice());
-        let mut slice = hasher.finish().to_le_bytes();
-        slice[0] = slice[0].wrapping_add(addresstype as u8);
-        Self(slice)
-    }
-}
-impl From<[u8; 8]> for AddressHash {
-    fn from(value: [u8; 8]) -> Self {
-        Self(value)
-    }
-}
-impl TryFrom<ByteView> for AddressHash {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<&AddressHash> for ByteView {
-    fn from(value: &AddressHash) -> Self {
-        Self::new(value.as_bytes())
-    }
-}
-impl From<AddressHash> for ByteView {
-    fn from(value: AddressHash) -> Self {
-        Self::from(&value)
-    }
-}
-
-#[derive(
-    Debug,
-    Deref,
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-)]
-pub struct BlockHashPrefix([u8; 8]);
-impl From<BlockHash> for BlockHashPrefix {
-    fn from(value: BlockHash) -> Self {
-        Self::from(&value)
-    }
-}
-impl From<&BlockHash> for BlockHashPrefix {
-    fn from(value: &BlockHash) -> Self {
-        Self(copy_first_8bytes(&value[..]).unwrap())
-    }
-}
-impl TryFrom<ByteView> for BlockHashPrefix {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<&BlockHashPrefix> for ByteView {
-    fn from(value: &BlockHashPrefix) -> Self {
-        Self::new(value.as_bytes())
-    }
-}
-impl From<BlockHashPrefix> for ByteView {
-    fn from(value: BlockHashPrefix) -> Self {
-        Self::from(&value)
-    }
-}
-
-#[derive(
-    Debug,
-    Deref,
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    FromBytes,
-    Immutable,
-    IntoBytes,
-    KnownLayout,
-)]
-pub struct TxidPrefix([u8; 8]);
-impl From<Txid> for TxidPrefix {
-    fn from(value: Txid) -> Self {
-        Self::from(&value)
-    }
-}
-impl From<&Txid> for TxidPrefix {
-    fn from(value: &Txid) -> Self {
-        Self(copy_first_8bytes(&value[..]).unwrap())
-    }
-}
-impl TryFrom<ByteView> for TxidPrefix {
-    type Error = Error;
-    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
-        Ok(Self::read_from_bytes(&value)?)
-    }
-}
-impl From<&TxidPrefix> for ByteView {
-    fn from(value: &TxidPrefix) -> Self {
-        Self::new(value.as_bytes())
-    }
-}
-impl From<TxidPrefix> for ByteView {
-    fn from(value: TxidPrefix) -> Self {
-        Self::from(&value)
-    }
-}
-impl From<[u8; 8]> for TxidPrefix {
-    fn from(value: [u8; 8]) -> Self {
-        Self(value)
-    }
-}
-
-fn copy_first_8bytes(slice: &[u8]) -> Result<[u8; 8], ()> {
-    let mut buf: [u8; 8] = [0; 8];
-    let buf_len = buf.len();
-    if slice.len() < buf_len {
-        return Err(());
-    }
-    slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
-        buf[i] = *r;
-    });
-    Ok(buf)
-}

crates/brk_core/src/structs/date.rs

@@ -1,8 +1,8 @@
 use jiff::{Span, civil::Date as Date_, tz::TimeZone};
 use serde::{Serialize, Serializer};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use super::{Dateindex, Timestamp};
+use super::{DateIndex, Timestamp};
 
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout,
@@ -58,9 +58,9 @@ impl From<Timestamp> for Date {
     }
 }
 
-impl From<Dateindex> for Date {
-    fn from(value: Dateindex) -> Self {
-        if value == Dateindex::default() {
+impl From<DateIndex> for Date {
+    fn from(value: DateIndex) -> Self {
+        if value == DateIndex::default() {
             Date::INDEX_ZERO
         } else {
             Self::from(

crates/brk_core/src/structs/dateindex.rs

@@ -2,7 +2,7 @@ use std::ops::Add;
 
 use serde::Serialize;
 // use color_eyre::eyre::eyre;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Error};
 
@@ -23,38 +23,38 @@ use super::Date;
     KnownLayout,
     Serialize,
 )]
-pub struct Dateindex(u16);
+pub struct DateIndex(u16);
 
-impl Dateindex {
+impl DateIndex {
     pub const BYTES: usize = size_of::<Self>();
 }
 
-impl From<Dateindex> for usize {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for usize {
+    fn from(value: DateIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl From<usize> for Dateindex {
+impl From<usize> for DateIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Dateindex> for i64 {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for i64 {
+    fn from(value: DateIndex) -> Self {
         value.0 as i64
     }
 }
 
-impl Add<usize> for Dateindex {
+impl Add<usize> for DateIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(self.0 + rhs as u16)
     }
 }
 
-impl TryFrom<Date> for Dateindex {
+impl TryFrom<Date> for DateIndex {
     type Error = Error;
     fn try_from(value: Date) -> Result<Self, Self::Error> {
         let value_ = jiff::civil::Date::from(value);
@@ -72,7 +72,7 @@ impl TryFrom<Date> for Dateindex {
     }
 }
 
-impl CheckedSub for Dateindex {
+impl CheckedSub for DateIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/decadeindex.rs

@@ -1,11 +1,11 @@
 use std::{fmt::Debug, ops::Add};
 
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex, Yearindex};
+use super::{Date, DateIndex, YearIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex, Yearindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Decadeindex(u8);
+pub struct DecadeIndex(u8);
 
-impl From<u8> for Decadeindex {
+impl From<u8> for DecadeIndex {
     fn from(value: u8) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Decadeindex {
+impl From<usize> for DecadeIndex {
     fn from(value: usize) -> Self {
         Self(value as u8)
     }
 }
 
-impl From<Decadeindex> for usize {
-    fn from(value: Decadeindex) -> Self {
+impl From<DecadeIndex> for usize {
+    fn from(value: DecadeIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Decadeindex {
+impl Add<usize> for DecadeIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Decadeindex {
     }
 }
 
-impl From<Dateindex> for Decadeindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for DecadeIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Decadeindex {
+impl From<Date> for DecadeIndex {
     fn from(value: Date) -> Self {
         let year = value.year();
         if year < 2000 {
@@ -67,14 +67,14 @@ impl From<Date> for Decadeindex {
     }
 }
 
-impl CheckedSub for Decadeindex {
+impl CheckedSub for DecadeIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }
 }
 
-impl From<Yearindex> for Decadeindex {
-    fn from(value: Yearindex) -> Self {
+impl From<YearIndex> for DecadeIndex {
+    fn from(value: YearIndex) -> Self {
         let v = usize::from(value);
         if v == 0 {
             Self(0)

crates/brk_core/src/structs/difficultyepoch.rs

@@ -1,7 +1,10 @@
-use std::{fmt::Debug, ops::Add};
+use std::{
+    fmt::Debug,
+    ops::{Add, Div},
+};
 
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
@@ -23,27 +26,35 @@ use super::Height;
     IntoBytes,
     KnownLayout,
 )]
-pub struct Difficultyepoch(u16);
+pub struct DifficultyEpoch(u16);
 
-impl From<u16> for Difficultyepoch {
+impl From<u16> for DifficultyEpoch {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Difficultyepoch {
+impl From<usize> for DifficultyEpoch {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Difficultyepoch> for usize {
-    fn from(value: Difficultyepoch) -> Self {
+impl From<DifficultyEpoch> for usize {
+    fn from(value: DifficultyEpoch) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Difficultyepoch {
+impl Add for DifficultyEpoch {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::from(self.0 + rhs.0)
+    }
+}
+
+impl Add<usize> for DifficultyEpoch {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +62,20 @@ impl Add<usize> for Difficultyepoch {
     }
 }
 
-impl From<Height> for Difficultyepoch {
+impl Div<usize> for DifficultyEpoch {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self::from(self.0 as usize / rhs)
+    }
+}
+
+impl From<Height> for DifficultyEpoch {
     fn from(value: Height) -> Self {
         Self((u32::from(value) / 2016) as u16)
     }
 }
 
-impl CheckedSub for Difficultyepoch {
+impl CheckedSub for DifficultyEpoch {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/dollars.rs

@@ -1,10 +1,10 @@
-use std::ops::{Add, Div};
+use std::ops::{Add, Div, Mul};
 
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use super::Cents;
+use super::{Bitcoin, Cents, Sats};
 
 #[derive(
     Debug,
@@ -49,14 +49,14 @@ impl From<usize> for Dollars {
 impl Add for Dollars {
     type Output = Self;
     fn add(self, rhs: Self) -> Self::Output {
-        Self(self.0 + rhs.0)
+        Self::from(Cents::from(self) + Cents::from(rhs))
     }
 }
 
 impl Div<usize> for Dollars {
     type Output = Self;
     fn div(self, rhs: usize) -> Self::Output {
-        Self(self.0 / rhs as f64)
+        Self::from(Cents::from(self) / rhs)
     }
 }
 
@@ -68,3 +68,12 @@ impl Ord for Dollars {
         self.0.partial_cmp(&other.0).unwrap()
     }
 }
+
+impl Mul<Bitcoin> for Dollars {
+    type Output = Dollars;
+    fn mul(self, rhs: Bitcoin) -> Self::Output {
+        Self::from(Cents::from(
+            u64::from(Sats::from(rhs)) * u64::from(Cents::from(self)) / u64::from(Sats::ONE_BTC),
+        ))
+    }
+}

crates/brk_core/src/structs/feerate.rs

@@ -1,5 +1,66 @@
-use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use std::ops::{Add, Div};
 
-#[derive(Debug, Clone, Copy, Serialize, FromBytes, Immutable, IntoBytes, KnownLayout)]
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use super::{Sats, StoredUsize};
+
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Serialize,
+    PartialEq,
+    PartialOrd,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
 pub struct Feerate(f32);
+
+impl From<(Sats, StoredUsize)> for Feerate {
+    fn from((sats, vsize): (Sats, StoredUsize)) -> Self {
+        Self((f64::from(sats) / f64::from(vsize)) as f32)
+    }
+}
+
+impl From<f64> for Feerate {
+    fn from(value: f64) -> Self {
+        Self(value as f32)
+    }
+}
+impl From<Feerate> for f64 {
+    fn from(value: Feerate) -> Self {
+        value.0 as f64
+    }
+}
+
+impl Add for Feerate {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Div<usize> for Feerate {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self((self.0 as f64 / rhs as f64) as f32)
+    }
+}
+
+impl From<usize> for Feerate {
+    fn from(value: usize) -> Self {
+        Self(value as f32)
+    }
+}
+
+impl Eq for Feerate {}
+
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for Feerate {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.partial_cmp(&other.0).unwrap()
+    }
+}

crates/brk_core/src/structs/halvingepoch.rs

@@ -1,7 +1,10 @@
-use std::{fmt::Debug, ops::Add};
+use std::{
+    fmt::Debug,
+    ops::{Add, Div},
+};
 
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
@@ -23,27 +26,35 @@ use super::Height;
     IntoBytes,
     KnownLayout,
 )]
-pub struct Halvingepoch(u8);
+pub struct HalvingEpoch(u8);
 
-impl From<u8> for Halvingepoch {
+impl From<u8> for HalvingEpoch {
     fn from(value: u8) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Halvingepoch {
+impl From<usize> for HalvingEpoch {
     fn from(value: usize) -> Self {
         Self(value as u8)
     }
 }
 
-impl From<Halvingepoch> for usize {
-    fn from(value: Halvingepoch) -> Self {
+impl From<HalvingEpoch> for usize {
+    fn from(value: HalvingEpoch) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Halvingepoch {
+impl Add for HalvingEpoch {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::from(self.0 + rhs.0)
+    }
+}
+
+impl Add<usize> for HalvingEpoch {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,14 +62,21 @@ impl Add<usize> for Halvingepoch {
     }
 }
 
-impl From<Height> for Halvingepoch {
+impl From<Height> for HalvingEpoch {
     fn from(value: Height) -> Self {
         Self((u32::from(value) / 210_000) as u8)
     }
 }
 
-impl CheckedSub for Halvingepoch {
+impl CheckedSub for HalvingEpoch {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }
 }
+
+impl Div<usize> for HalvingEpoch {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self::from(self.0 as usize / rhs)
+    }
+}

crates/brk_core/src/structs/height.rs

@@ -5,7 +5,8 @@ use std::{
 
 use bitcoincore_rpc::{Client, RpcApi};
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
@@ -28,8 +29,8 @@ use crate::CheckedSub;
 pub struct Height(u32);
 
 impl Height {
-    pub const ZERO: Self = Height(0);
-    pub const MAX: Self = Height(u32::MAX);
+    pub const ZERO: Self = Self(0);
+    pub const MAX: Self = Self(u32::MAX);
 
     pub fn new(height: u32) -> Self {
         Self(height)
@@ -181,12 +182,6 @@ impl From<bitcoin::locktime::absolute::Height> for Height {
     }
 }
 
-impl From<Height> for bitcoin::locktime::absolute::Height {
-    fn from(value: Height) -> Self {
-        bitcoin::locktime::absolute::Height::from_consensus(value.0).unwrap()
-    }
-}
-
 impl TryFrom<&std::path::Path> for Height {
     type Error = crate::Error;
     fn try_from(value: &std::path::Path) -> Result<Self, Self::Error> {

crates/brk_core/src/structs/inputindex.rs

@@ -2,7 +2,7 @@ use std::ops::{Add, AddAssign};
 
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
@@ -25,49 +25,49 @@ use super::Vin;
     KnownLayout,
     Serialize,
 )]
-pub struct Txinindex(u64);
+pub struct InputIndex(u64);
 
-impl Txinindex {
+impl InputIndex {
     pub fn incremented(self) -> Self {
         Self(*self + 1)
     }
 }
 
-impl Add<Txinindex> for Txinindex {
+impl Add<InputIndex> for InputIndex {
     type Output = Self;
-    fn add(self, rhs: Txinindex) -> Self::Output {
+    fn add(self, rhs: InputIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }
 
-impl Add<Vin> for Txinindex {
+impl Add<Vin> for InputIndex {
     type Output = Self;
     fn add(self, rhs: Vin) -> Self::Output {
         Self(self.0 + u64::from(rhs))
     }
 }
 
-impl Add<usize> for Txinindex {
+impl Add<usize> for InputIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(self.0 + rhs as u64)
     }
 }
 
-impl AddAssign<Txinindex> for Txinindex {
-    fn add_assign(&mut self, rhs: Txinindex) {
+impl AddAssign<InputIndex> for InputIndex {
+    fn add_assign(&mut self, rhs: InputIndex) {
         self.0 += rhs.0
     }
 }
 
-impl CheckedSub<Txinindex> for Txinindex {
+impl CheckedSub<InputIndex> for InputIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self::from)
     }
 }
 
-impl From<Txinindex> for u32 {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for u32 {
+    fn from(value: InputIndex) -> Self {
         if value.0 > u32::MAX as u64 {
             panic!()
         }
@@ -75,24 +75,24 @@ impl From<Txinindex> for u32 {
     }
 }
 
-impl From<u64> for Txinindex {
+impl From<u64> for InputIndex {
     fn from(value: u64) -> Self {
         Self(value)
     }
 }
-impl From<Txinindex> for u64 {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for u64 {
+    fn from(value: InputIndex) -> Self {
         value.0
     }
 }
 
-impl From<usize> for Txinindex {
+impl From<usize> for InputIndex {
     fn from(value: usize) -> Self {
         Self(value as u64)
     }
 }
-impl From<Txinindex> for usize {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for usize {
+    fn from(value: InputIndex) -> Self {
         value.0 as usize
     }
 }

crates/brk_core/src/structs/locktime.rs

@@ -1,30 +0,0 @@
-use serde::Serialize;
-use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
-
-use super::{Height, Timestamp};
-
-#[derive(Debug, Immutable, Clone, Copy, IntoBytes, KnownLayout, TryFromBytes, Serialize)]
-#[repr(C)]
-#[allow(warnings)]
-pub enum LockTime {
-    Height(Height),
-    Timestamp(Timestamp),
-}
-
-impl From<bitcoin::absolute::LockTime> for LockTime {
-    fn from(value: bitcoin::absolute::LockTime) -> Self {
-        match value {
-            bitcoin::absolute::LockTime::Blocks(h) => LockTime::Height(h.into()),
-            bitcoin::absolute::LockTime::Seconds(t) => LockTime::Timestamp(t.into()),
-        }
-    }
-}
-
-impl From<LockTime> for bitcoin::absolute::LockTime {
-    fn from(value: LockTime) -> Self {
-        match value {
-            LockTime::Height(h) => bitcoin::absolute::LockTime::Blocks(h.into()),
-            LockTime::Timestamp(t) => bitcoin::absolute::LockTime::Seconds(t.into()),
-        }
-    }
-}

crates/brk_core/src/structs/mod.rs

@@ -1,12 +1,12 @@
 mod addressbytes;
-mod addressindex;
-mod addressindextxoutindex;
-mod addresstype;
-mod addresstypeindex;
+mod addressbyteshash;
+// mod addressindex;
+// mod addressindexoutputindex;
+// mod addresstype;
 mod bitcoin;
 mod blockhash;
+mod blockhashprefix;
 mod cents;
-mod compressed;
 mod date;
 mod dateindex;
 mod decadeindex;
@@ -15,16 +15,24 @@ mod dollars;
 mod feerate;
 mod halvingepoch;
 mod height;
-mod locktime;
+mod inputindex;
 mod monthindex;
 mod ohlc;
+mod outputindex;
+mod outputtype;
+mod outputtypeindex;
 mod quarterindex;
+mod rawlocktime;
 mod sats;
+mod stored_f64;
+mod stored_u32;
+mod stored_u64;
+mod stored_u8;
+mod stored_usize;
 mod timestamp;
 mod txid;
+mod txidprefix;
 mod txindex;
-mod txinindex;
-mod txoutindex;
 mod txversion;
 mod unit;
 mod vin;
@@ -34,14 +42,14 @@ mod weight;
 mod yearindex;
 
 pub use addressbytes::*;
-pub use addressindex::*;
-pub use addressindextxoutindex::*;
-pub use addresstype::*;
-pub use addresstypeindex::*;
+pub use addressbyteshash::*;
+// pub use addressindex::*;
+// pub use addressindexoutputindex::*;
+// pub use addresstype::*;
 pub use bitcoin::*;
 pub use blockhash::*;
+pub use blockhashprefix::*;
 pub use cents::*;
-pub use compressed::*;
 pub use date::*;
 pub use dateindex::*;
 pub use decadeindex::*;
@@ -50,16 +58,24 @@ pub use dollars::*;
 pub use feerate::*;
 pub use halvingepoch::*;
 pub use height::*;
-pub use locktime::*;
+pub use inputindex::*;
 pub use monthindex::*;
 pub use ohlc::*;
+pub use outputindex::*;
+pub use outputtype::*;
+pub use outputtypeindex::*;
 pub use quarterindex::*;
+pub use rawlocktime::*;
 pub use sats::*;
+pub use stored_f64::*;
+pub use stored_u8::*;
+pub use stored_u32::*;
+pub use stored_u64::*;
+pub use stored_usize::*;
 pub use timestamp::*;
 pub use txid::*;
+pub use txidprefix::*;
 pub use txindex::*;
-pub use txinindex::*;
-pub use txoutindex::*;
 pub use txversion::*;
 pub use unit::*;
 pub use vin::*;

crates/brk_core/src/structs/monthindex.rs

@@ -1,11 +1,11 @@
 use std::{fmt::Debug, ops::Add};
 
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex, Yearindex};
+use super::{Date, DateIndex, YearIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex, Yearindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Monthindex(u16);
+pub struct MonthIndex(u16);
 
-impl From<u16> for Monthindex {
+impl From<u16> for MonthIndex {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Monthindex {
+impl From<usize> for MonthIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Monthindex> for usize {
-    fn from(value: Monthindex) -> Self {
+impl From<MonthIndex> for usize {
+    fn from(value: MonthIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Monthindex {
+impl Add<usize> for MonthIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,19 +51,19 @@ impl Add<usize> for Monthindex {
     }
 }
 
-impl From<Dateindex> for Monthindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for MonthIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Monthindex {
+impl From<Date> for MonthIndex {
     fn from(value: Date) -> Self {
-        Self(u16::from(Yearindex::from(value)) * 12 + value.month() as u16 - 1)
+        Self(u16::from(YearIndex::from(value)) * 12 + value.month() as u16 - 1)
     }
 }
 
-impl CheckedSub for Monthindex {
+impl CheckedSub for MonthIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/ohlc.rs

@@ -2,11 +2,11 @@ use std::ops::{Add, Div};
 
 use derive_deref::Deref;
 use serde::{Serialize, Serializer, ser::SerializeTuple};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::{Cents, Dollars, Sats};
 
-#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize)]
+#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
 #[repr(C)]
 pub struct OHLCCents {
     pub open: Open<Cents>,
@@ -37,6 +37,20 @@ impl From<Close<Cents>> for OHLCCents {
     }
 }
 
+impl Serialize for OHLCCents {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut tup = serializer.serialize_tuple(4)?;
+        tup.serialize_element(&self.open)?;
+        tup.serialize_element(&self.high)?;
+        tup.serialize_element(&self.low)?;
+        tup.serialize_element(&self.close)?;
+        tup.end()
+    }
+}
+
 #[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
 #[repr(C)]
 pub struct OHLCDollars {
@@ -99,6 +113,51 @@ impl From<&OHLCCents> for OHLCDollars {
     }
 }
 
+#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
+#[repr(C)]
+pub struct OHLCSats {
+    pub open: Open<Sats>,
+    pub high: High<Sats>,
+    pub low: Low<Sats>,
+    pub close: Close<Sats>,
+}
+
+impl Serialize for OHLCSats {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut tup = serializer.serialize_tuple(4)?;
+        tup.serialize_element(&self.open)?;
+        tup.serialize_element(&self.high)?;
+        tup.serialize_element(&self.low)?;
+        tup.serialize_element(&self.close)?;
+        tup.end()
+    }
+}
+
+impl From<(Open<Sats>, High<Sats>, Low<Sats>, Close<Sats>)> for OHLCSats {
+    fn from(value: (Open<Sats>, High<Sats>, Low<Sats>, Close<Sats>)) -> Self {
+        Self {
+            open: value.0,
+            high: value.1,
+            low: value.2,
+            close: value.3,
+        }
+    }
+}
+
+impl From<Close<Sats>> for OHLCSats {
+    fn from(value: Close<Sats>) -> Self {
+        Self {
+            open: Open::from(value),
+            high: High::from(value),
+            low: Low::from(value),
+            close: value,
+        }
+    }
+}
+
 #[derive(
     Debug,
     Default,
@@ -117,12 +176,40 @@ impl From<&OHLCCents> for OHLCDollars {
 )]
 #[repr(C)]
 pub struct Open<T>(T);
-impl<T> From<T> for Open<T> {
-    fn from(value: T) -> Self {
+
+impl<T> Open<T> {
+    pub fn new(value: T) -> Self {
         Self(value)
     }
 }
 
+impl<T> From<usize> for Open<T>
+where
+    T: From<usize>,
+{
+    fn from(value: usize) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<f64> for Open<T>
+where
+    T: From<f64>,
+{
+    fn from(value: f64) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<Open<T>> for f64
+where
+    f64: From<T>,
+{
+    fn from(value: Open<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
 impl<T> From<Close<T>> for Open<T>
 where
     T: Copy,
@@ -138,24 +225,6 @@ impl From<Open<Cents>> for Open<Dollars> {
     }
 }
 
-impl From<usize> for Open<Dollars> {
-    fn from(value: usize) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<f64> for Open<Dollars> {
-    fn from(value: f64) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<Open<Dollars>> for f64 {
-    fn from(value: Open<Dollars>) -> Self {
-        Self::from(value.0)
-    }
-}
-
 impl<T> Add for Open<T>
 where
     T: Add<Output = T>,
@@ -194,12 +263,40 @@ where
 )]
 #[repr(C)]
 pub struct High<T>(T);
-impl<T> From<T> for High<T> {
-    fn from(value: T) -> Self {
+
+impl<T> High<T> {
+    pub fn new(value: T) -> Self {
         Self(value)
     }
 }
 
+impl<T> From<usize> for High<T>
+where
+    T: From<usize>,
+{
+    fn from(value: usize) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<f64> for High<T>
+where
+    T: From<f64>,
+{
+    fn from(value: f64) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<High<T>> for f64
+where
+    f64: From<T>,
+{
+    fn from(value: High<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
 impl<T> From<Close<T>> for High<T>
 where
     T: Copy,
@@ -215,24 +312,6 @@ impl From<High<Cents>> for High<Dollars> {
     }
 }
 
-impl From<usize> for High<Dollars> {
-    fn from(value: usize) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<f64> for High<Dollars> {
-    fn from(value: f64) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<High<Dollars>> for f64 {
-    fn from(value: High<Dollars>) -> Self {
-        Self::from(value.0)
-    }
-}
-
 impl<T> Add for High<T>
 where
     T: Add<Output = T>,
@@ -271,12 +350,40 @@ where
 )]
 #[repr(C)]
 pub struct Low<T>(T);
-impl<T> From<T> for Low<T> {
-    fn from(value: T) -> Self {
+
+impl<T> Low<T> {
+    pub fn new(value: T) -> Self {
         Self(value)
     }
 }
 
+impl<T> From<usize> for Low<T>
+where
+    T: From<usize>,
+{
+    fn from(value: usize) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<f64> for Low<T>
+where
+    T: From<f64>,
+{
+    fn from(value: f64) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<Low<T>> for f64
+where
+    f64: From<T>,
+{
+    fn from(value: Low<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
 impl<T> From<Close<T>> for Low<T>
 where
     T: Copy,
@@ -292,24 +399,6 @@ impl From<Low<Cents>> for Low<Dollars> {
     }
 }
 
-impl From<usize> for Low<Dollars> {
-    fn from(value: usize) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<f64> for Low<Dollars> {
-    fn from(value: f64) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<Low<Dollars>> for f64 {
-    fn from(value: Low<Dollars>) -> Self {
-        Self::from(value.0)
-    }
-}
-
 impl<T> Add for Low<T>
 where
     T: Add<Output = T>,
@@ -348,54 +437,52 @@ where
 )]
 #[repr(C)]
 pub struct Close<T>(T);
-impl<T> From<T> for Close<T> {
-    fn from(value: T) -> Self {
+
+impl<T> Close<T> {
+    pub fn new(value: T) -> Self {
         Self(value)
     }
 }
 
+impl<T> From<usize> for Close<T>
+where
+    T: From<usize>,
+{
+    fn from(value: usize) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<f64> for Close<T>
+where
+    T: From<f64>,
+{
+    fn from(value: f64) -> Self {
+        Self(T::from(value))
+    }
+}
+
+impl<T> From<Close<T>> for f64
+where
+    f64: From<T>,
+{
+    fn from(value: Close<T>) -> Self {
+        Self::from(value.0)
+    }
+}
+
+// impl<A, B> From<Close<A>> for Close<B>
+// where
+//     B: From<A>,
+// {
+//     fn from(value: Close<A>) -> Self {
+//         Self(B::from(*value))
 impl From<Close<Cents>> for Close<Dollars> {
     fn from(value: Close<Cents>) -> Self {
         Self(Dollars::from(*value))
     }
 }
 
-impl From<usize> for Close<Dollars> {
-    fn from(value: usize) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<usize> for Close<Sats> {
-    fn from(value: usize) -> Self {
-        Self(Sats::from(value))
-    }
-}
-
-impl From<f64> for Close<Dollars> {
-    fn from(value: f64) -> Self {
-        Self(Dollars::from(value))
-    }
-}
-
-impl From<f64> for Close<Sats> {
-    fn from(value: f64) -> Self {
-        Self(Sats::from(value))
-    }
-}
-
-impl From<Close<Dollars>> for f64 {
-    fn from(value: Close<Dollars>) -> Self {
-        Self::from(value.0)
-    }
-}
-
-impl From<Close<Sats>> for f64 {
-    fn from(value: Close<Sats>) -> Self {
-        Self::from(value.0)
-    }
-}
-
 impl<T> Add for Close<T>
 where
     T: Add<Output = T>,

crates/brk_core/src/structs/outputindex.rs

@@ -2,7 +2,7 @@ use std::ops::{Add, AddAssign};
 
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
@@ -25,9 +25,9 @@ use super::Vout;
     KnownLayout,
     Serialize,
 )]
-pub struct Txoutindex(u64);
+pub struct OutputIndex(u64);
 
-impl Txoutindex {
+impl OutputIndex {
     pub const COINBASE: Self = Self(u64::MAX);
 
     pub fn incremented(self) -> Self {
@@ -39,41 +39,41 @@ impl Txoutindex {
     }
 }
 
-impl Add<Txoutindex> for Txoutindex {
+impl Add<OutputIndex> for OutputIndex {
     type Output = Self;
-    fn add(self, rhs: Txoutindex) -> Self::Output {
+    fn add(self, rhs: OutputIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }
 
-impl Add<Vout> for Txoutindex {
+impl Add<Vout> for OutputIndex {
     type Output = Self;
     fn add(self, rhs: Vout) -> Self::Output {
         Self(self.0 + u64::from(rhs))
     }
 }
 
-impl Add<usize> for Txoutindex {
+impl Add<usize> for OutputIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(self.0 + rhs as u64)
     }
 }
 
-impl AddAssign<Txoutindex> for Txoutindex {
-    fn add_assign(&mut self, rhs: Txoutindex) {
+impl AddAssign<OutputIndex> for OutputIndex {
+    fn add_assign(&mut self, rhs: OutputIndex) {
         self.0 += rhs.0
     }
 }
 
-impl CheckedSub<Txoutindex> for Txoutindex {
+impl CheckedSub<OutputIndex> for OutputIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self::from)
     }
 }
 
-impl From<Txoutindex> for u32 {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for u32 {
+    fn from(value: OutputIndex) -> Self {
         if value.0 > u32::MAX as u64 {
             panic!()
         }
@@ -81,24 +81,24 @@ impl From<Txoutindex> for u32 {
     }
 }
 
-impl From<u64> for Txoutindex {
+impl From<u64> for OutputIndex {
     fn from(value: u64) -> Self {
         Self(value)
     }
 }
-impl From<Txoutindex> for u64 {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for u64 {
+    fn from(value: OutputIndex) -> Self {
         value.0
     }
 }
 
-impl From<usize> for Txoutindex {
+impl From<usize> for OutputIndex {
     fn from(value: usize) -> Self {
         Self(value as u64)
     }
 }
-impl From<Txoutindex> for usize {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for usize {
+    fn from(value: OutputIndex) -> Self {
         value.0 as usize
     }
 }

crates/brk_core/src/structs/outputtype.rs

@@ -1,27 +1,38 @@
-use bitcoin::ScriptBuf;
+use bitcoin::{ScriptBuf, opcodes::all::OP_PUSHBYTES_2};
 use serde::Serialize;
-use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+use zerocopy_derive::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
 
 #[derive(
-    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, TryFromBytes, Immutable, IntoBytes, KnownLayout, Serialize,
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    TryFromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
 )]
 #[repr(u8)]
-pub enum Addresstype {
+pub enum OutputType {
     P2PK65,
     P2PK33,
     P2PKH,
+    P2MS,
     P2SH,
+    OpReturn,
     P2WPKH,
     P2WSH,
     P2TR,
-    Multisig = 251,
-    PushOnly = 252,
-    OpReturn = 253,
+    P2A,
     Empty = 254,
     Unknown = 255,
 }
 
-impl From<&ScriptBuf> for Addresstype {
+impl From<&ScriptBuf> for OutputType {
     fn from(script: &ScriptBuf) -> Self {
         if script.is_p2pk() {
             let bytes = script.as_bytes();
@@ -36,22 +47,26 @@ impl From<&ScriptBuf> for Addresstype {
             }
         } else if script.is_p2pkh() {
             Self::P2PKH
+        } else if script.is_multisig() {
+            Self::P2MS
         } else if script.is_p2sh() {
             Self::P2SH
+        } else if script.is_op_return() {
+            Self::OpReturn
         } else if script.is_p2wpkh() {
             Self::P2WPKH
         } else if script.is_p2wsh() {
             Self::P2WSH
         } else if script.is_p2tr() {
             Self::P2TR
+        } else if script.witness_version() == Some(bitcoin::WitnessVersion::V1)
+            && script.len() == 4
+            && script.as_bytes()[1] == OP_PUSHBYTES_2.to_u8()
+            && script.as_bytes()[2..4] == [78, 115]
+        {
+            Self::P2A
         } else if script.is_empty() {
             Self::Empty
-        } else if script.is_op_return() {
-            Self::OpReturn
-        } else if script.is_push_only() {
-            Self::PushOnly
-        } else if script.is_multisig() {
-            Self::Multisig
         } else {
             Self::Unknown
         }

crates/brk_core/src/structs/outputtypeindex.rs

@@ -0,0 +1,635 @@
+use std::ops::Add;
+
+use byteview::ByteView;
+use derive_deref::{Deref, DerefMut};
+use serde::Serialize;
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{CheckedSub, Error};
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct OutputTypeIndex(u32);
+
+impl OutputTypeIndex {
+    pub fn increment(&mut self) {
+        self.0 += 1;
+    }
+
+    pub fn incremented(self) -> Self {
+        Self(self.0 + 1)
+    }
+
+    pub fn copy_then_increment(&mut self) -> Self {
+        let i = *self;
+        self.increment();
+        i
+    }
+}
+
+impl From<u32> for OutputTypeIndex {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<u64> for OutputTypeIndex {
+    fn from(value: u64) -> Self {
+        Self(value as u32)
+    }
+}
+impl From<OutputTypeIndex> for u64 {
+    fn from(value: OutputTypeIndex) -> Self {
+        value.0 as u64
+    }
+}
+
+impl From<usize> for OutputTypeIndex {
+    fn from(value: usize) -> Self {
+        Self(value as u32)
+    }
+}
+impl From<OutputTypeIndex> for usize {
+    fn from(value: OutputTypeIndex) -> Self {
+        value.0 as usize
+    }
+}
+
+impl Add<usize> for OutputTypeIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(self.0 + rhs as u32)
+    }
+}
+
+impl Add<OutputTypeIndex> for OutputTypeIndex {
+    type Output = Self;
+    fn add(self, rhs: OutputTypeIndex) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+impl TryFrom<ByteView> for OutputTypeIndex {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<OutputTypeIndex> for ByteView {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct EmptyOutputIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for EmptyOutputIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<EmptyOutputIndex> for usize {
+    fn from(value: EmptyOutputIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for EmptyOutputIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for EmptyOutputIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<EmptyOutputIndex> for EmptyOutputIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2MSIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2MSIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2MSIndex> for usize {
+    fn from(value: P2MSIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2MSIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2MSIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2MSIndex> for P2MSIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2AIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2AIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2AIndex> for usize {
+    fn from(value: P2AIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2AIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2AIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2AIndex> for P2AIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct OpReturnIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for OpReturnIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<OpReturnIndex> for usize {
+    fn from(value: OpReturnIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for OpReturnIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for OpReturnIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<OpReturnIndex> for OpReturnIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct UnknownOutputIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for UnknownOutputIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<UnknownOutputIndex> for usize {
+    fn from(value: UnknownOutputIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for UnknownOutputIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for UnknownOutputIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<UnknownOutputIndex> for UnknownOutputIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2PK33Index(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2PK33Index {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2PK33Index> for usize {
+    fn from(value: P2PK33Index) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2PK33Index {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2PK33Index {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2PK33Index> for P2PK33Index {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2PK65Index(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2PK65Index {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2PK65Index> for usize {
+    fn from(value: P2PK65Index) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2PK65Index {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2PK65Index {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2PK65Index> for P2PK65Index {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2PKHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2PKHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2PKHIndex> for usize {
+    fn from(value: P2PKHIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2PKHIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2PKHIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2PKHIndex> for P2PKHIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2SHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2SHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2SHIndex> for usize {
+    fn from(value: P2SHIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2SHIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2SHIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2SHIndex> for P2SHIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2TRIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2TRIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2TRIndex> for usize {
+    fn from(value: P2TRIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2TRIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2TRIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2TRIndex> for P2TRIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2WPKHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2WPKHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2WPKHIndex> for usize {
+    fn from(value: P2WPKHIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2WPKHIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2WPKHIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2WPKHIndex> for P2WPKHIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct P2WSHIndex(OutputTypeIndex);
+impl From<OutputTypeIndex> for P2WSHIndex {
+    fn from(value: OutputTypeIndex) -> Self {
+        Self(value)
+    }
+}
+impl From<P2WSHIndex> for usize {
+    fn from(value: P2WSHIndex) -> Self {
+        Self::from(*value)
+    }
+}
+impl From<usize> for P2WSHIndex {
+    fn from(value: usize) -> Self {
+        Self(OutputTypeIndex::from(value))
+    }
+}
+impl Add<usize> for P2WSHIndex {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(*self + rhs)
+    }
+}
+impl CheckedSub<P2WSHIndex> for P2WSHIndex {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        self.0.0.checked_sub(rhs.0.0).map(OutputTypeIndex).map(Self)
+    }
+}

crates/brk_core/src/structs/quarterindex.rs

@@ -1,11 +1,11 @@
 use std::{fmt::Debug, ops::Add};
 
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::Monthindex;
+use super::MonthIndex;
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::Monthindex;
     IntoBytes,
     KnownLayout,
 )]
-pub struct Quarterindex(u16);
+pub struct QuarterIndex(u16);
 
-impl From<u16> for Quarterindex {
+impl From<u16> for QuarterIndex {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Quarterindex {
+impl From<usize> for QuarterIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Quarterindex> for usize {
-    fn from(value: Quarterindex) -> Self {
+impl From<QuarterIndex> for usize {
+    fn from(value: QuarterIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Quarterindex {
+impl Add<usize> for QuarterIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Quarterindex {
     }
 }
 
-impl From<Monthindex> for Quarterindex {
-    fn from(value: Monthindex) -> Self {
+impl From<MonthIndex> for QuarterIndex {
+    fn from(value: MonthIndex) -> Self {
         Self((usize::from(value) / 3) as u16)
     }
 }
 
-impl CheckedSub for Quarterindex {
+impl CheckedSub for QuarterIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

crates/brk_core/src/structs/rawlocktime.rs

@@ -0,0 +1,29 @@
+use bitcoin::absolute::LockTime;
+use serde::Serialize;
+use zerocopy_derive::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+
+#[derive(Debug, Immutable, Clone, Copy, IntoBytes, KnownLayout, TryFromBytes, Serialize)]
+pub struct RawLockTime(u32);
+
+impl From<LockTime> for RawLockTime {
+    fn from(value: LockTime) -> Self {
+        Self(value.to_consensus_u32())
+    }
+}
+
+const CONSENSUS_DELIMITER: u32 = 500_000_000;
+
+impl From<RawLockTime> for LockTime {
+    fn from(value: RawLockTime) -> Self {
+        let value = value.0;
+        if value >= CONSENSUS_DELIMITER {
+            bitcoin::locktime::absolute::Height::from_consensus(value)
+                .unwrap()
+                .into()
+        } else {
+            bitcoin::locktime::absolute::Time::from_consensus(value)
+                .unwrap()
+                .into()
+        }
+    }
+}

crates/brk_core/src/structs/sats.rs

@@ -5,11 +5,11 @@ use std::{
 
 use bitcoin::Amount;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Bitcoin, Dollars, Height};
+use super::{Bitcoin, Cents, Dollars, Height};
 
 #[derive(
     Debug,
@@ -30,6 +30,7 @@ pub struct Sats(u64);
 
 impl Sats {
     pub const ZERO: Self = Self(0);
+    pub const MAX: Self = Self(u64::MAX);
     pub const ONE_BTC: Self = Self(100_000_000);
 
     pub fn is_zero(&self) -> bool {
@@ -39,8 +40,8 @@ impl Sats {
 
 impl Add for Sats {
     type Output = Self;
-    fn add(self, rhs: Sats) -> Self::Output {
-        Sats::from(self.0 + rhs.0)
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::from(self.0 + rhs.0)
     }
 }
 
@@ -93,7 +94,12 @@ impl Sum for Sats {
 impl Div<Dollars> for Sats {
     type Output = Self;
     fn div(self, rhs: Dollars) -> Self::Output {
-        Self((self.0 as f64 / f64::from(rhs)) as u64)
+        let raw_cents = u64::from(Cents::from(rhs));
+        if raw_cents != 0 {
+            Self(self.0 * 100 / raw_cents)
+        } else {
+            Self::MAX
+        }
     }
 }
 
@@ -118,7 +124,7 @@ impl From<usize> for Sats {
 
 impl From<f64> for Sats {
     fn from(value: f64) -> Self {
-        Self(value as u64)
+        Self(value.round() as u64)
     }
 }
 
@@ -141,7 +147,7 @@ impl From<Sats> for Amount {
 
 impl From<Bitcoin> for Sats {
     fn from(value: Bitcoin) -> Self {
-        Self((f64::from(value) * (u64::from(Sats::ONE_BTC) as f64)) as u64)
+        Self((f64::from(value) * (Sats::ONE_BTC.0 as f64)).round() as u64)
     }
 }
 

crates/brk_core/src/structs/stored_f64.rs

@@ -0,0 +1,69 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    PartialOrd,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct StoredF64(f64);
+
+impl From<f64> for StoredF64 {
+    fn from(value: f64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for StoredF64 {
+    fn from(value: usize) -> Self {
+        Self(value as f64)
+    }
+}
+
+impl CheckedSub<StoredF64> for StoredF64 {
+    fn checked_sub(self, rhs: Self) -> Option<Self> {
+        Some(Self(self.0 - rhs.0))
+    }
+}
+
+impl Div<usize> for StoredF64 {
+    type Output = Self;
+    fn div(self, rhs: usize) -> Self::Output {
+        Self(self.0 / rhs as f64)
+    }
+}
+
+impl Add for StoredF64 {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl From<StoredF64> for f64 {
+    fn from(value: StoredF64) -> Self {
+        value.0
+    }
+}
+
+impl Eq for StoredF64 {}
+
+#[allow(clippy::derive_ord_xor_partial_ord)]
+impl Ord for StoredF64 {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.partial_cmp(&other.0).unwrap()
+    }
+}

crates/brk_core/src/structs/stored_u32.rs

@@ -0,0 +1,165 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+use super::{
+    EmptyOutputIndex, OpReturnIndex, P2AIndex, P2MSIndex, P2PK33Index, P2PK65Index, P2PKHIndex,
+    P2SHIndex, P2TRIndex, P2WPKHIndex, P2WSHIndex, UnknownOutputIndex,
+};
+
+#[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 {
+        if value > u32::MAX as usize {
+            panic!("usize too big (value = {value})")
+        }
+        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
+    }
+}
+
+impl From<StoredU32> for usize {
+    fn from(value: StoredU32) -> Self {
+        value.0 as usize
+    }
+}
+
+impl From<P2PK65Index> for StoredU32 {
+    fn from(value: P2PK65Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PK33Index> for StoredU32 {
+    fn from(value: P2PK33Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PKHIndex> for StoredU32 {
+    fn from(value: P2PKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<OpReturnIndex> for StoredU32 {
+    fn from(value: OpReturnIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2MSIndex> for StoredU32 {
+    fn from(value: P2MSIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2SHIndex> for StoredU32 {
+    fn from(value: P2SHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WSHIndex> for StoredU32 {
+    fn from(value: P2WSHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WPKHIndex> for StoredU32 {
+    fn from(value: P2WPKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2TRIndex> for StoredU32 {
+    fn from(value: P2TRIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2AIndex> for StoredU32 {
+    fn from(value: P2AIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<UnknownOutputIndex> for StoredU32 {
+    fn from(value: UnknownOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<EmptyOutputIndex> for StoredU32 {
+    fn from(value: EmptyOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}

crates/brk_core/src/structs/stored_u64.rs

@@ -0,0 +1,99 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+use super::{InputIndex, OutputIndex, TxIndex};
+
+#[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<TxIndex> for StoredU64 {
+    fn from(value: TxIndex) -> Self {
+        Self(*value as u64)
+    }
+}
+
+impl From<InputIndex> for StoredU64 {
+    fn from(value: InputIndex) -> Self {
+        Self(*value)
+    }
+}
+
+impl From<OutputIndex> for StoredU64 {
+    fn from(value: OutputIndex) -> Self {
+        Self(*value)
+    }
+}

crates/brk_core/src/structs/stored_u8.rs

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

crates/brk_core/src/structs/stored_usize.rs

@@ -0,0 +1,193 @@
+use std::ops::{Add, Div};
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::CheckedSub;
+
+use super::{
+    DateIndex, EmptyOutputIndex, Height, InputIndex, MonthIndex, OpReturnIndex, OutputIndex,
+    P2AIndex, P2MSIndex, P2PK33Index, P2PK65Index, P2PKHIndex, P2SHIndex, P2TRIndex, P2WPKHIndex,
+    P2WSHIndex, TxIndex, UnknownOutputIndex, YearIndex,
+};
+
+#[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
+    }
+}
+
+impl From<Height> for StoredUsize {
+    fn from(value: Height) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<DateIndex> for StoredUsize {
+    fn from(value: DateIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<MonthIndex> for StoredUsize {
+    fn from(value: MonthIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<YearIndex> for StoredUsize {
+    fn from(value: YearIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<OutputIndex> for StoredUsize {
+    fn from(value: OutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<InputIndex> for StoredUsize {
+    fn from(value: InputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<TxIndex> for StoredUsize {
+    fn from(value: TxIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PK65Index> for StoredUsize {
+    fn from(value: P2PK65Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PK33Index> for StoredUsize {
+    fn from(value: P2PK33Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PKHIndex> for StoredUsize {
+    fn from(value: P2PKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<OpReturnIndex> for StoredUsize {
+    fn from(value: OpReturnIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2MSIndex> for StoredUsize {
+    fn from(value: P2MSIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2SHIndex> for StoredUsize {
+    fn from(value: P2SHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WSHIndex> for StoredUsize {
+    fn from(value: P2WSHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WPKHIndex> for StoredUsize {
+    fn from(value: P2WPKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2TRIndex> for StoredUsize {
+    fn from(value: P2TRIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2AIndex> for StoredUsize {
+    fn from(value: P2AIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<UnknownOutputIndex> for StoredUsize {
+    fn from(value: UnknownOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<EmptyOutputIndex> for StoredUsize {
+    fn from(value: EmptyOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}

crates/brk_core/src/structs/timestamp.rs

@@ -3,7 +3,7 @@ use std::ops::{Add, Div};
 use derive_deref::Deref;
 use jiff::{civil::date, tz::TimeZone};
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
@@ -65,12 +65,6 @@ impl From<bitcoin::locktime::absolute::Time> for Timestamp {
     }
 }
 
-impl From<Timestamp> for bitcoin::locktime::absolute::Time {
-    fn from(value: Timestamp) -> Self {
-        bitcoin::locktime::absolute::Time::from_consensus(*value).unwrap()
-    }
-}
-
 impl From<usize> for Timestamp {
     fn from(value: usize) -> Self {
         Self(value as u32)

crates/brk_core/src/structs/txid.rs

@@ -3,7 +3,7 @@ use std::{fmt, mem};
 use bitcoin::hashes::Hash;
 use derive_deref::Deref;
 use serde::{Serialize, Serializer};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 #[derive(Debug, Deref, Clone, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes)]
 pub struct Txid([u8; 32]);

crates/brk_core/src/structs/txidprefix.rs

@@ -0,0 +1,61 @@
+use byteview::ByteView;
+use derive_deref::Deref;
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{Error, copy_first_8bytes};
+
+use super::Txid;
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+)]
+pub struct TxidPrefix([u8; 8]);
+
+impl From<Txid> for TxidPrefix {
+    fn from(value: Txid) -> Self {
+        Self::from(&value)
+    }
+}
+
+impl From<&Txid> for TxidPrefix {
+    fn from(value: &Txid) -> Self {
+        Self(copy_first_8bytes(&value[..]).unwrap())
+    }
+}
+
+impl TryFrom<ByteView> for TxidPrefix {
+    type Error = Error;
+    fn try_from(value: ByteView) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+
+impl From<&TxidPrefix> for ByteView {
+    fn from(value: &TxidPrefix) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+
+impl From<TxidPrefix> for ByteView {
+    fn from(value: TxidPrefix) -> Self {
+        Self::from(&value)
+    }
+}
+
+impl From<[u8; 8]> for TxidPrefix {
+    fn from(value: [u8; 8]) -> Self {
+        Self(value)
+    }
+}

crates/brk_core/src/structs/txindex.rs

@@ -3,10 +3,13 @@ use std::ops::{Add, AddAssign};
 use byteview::ByteView;
 use derive_deref::{Deref, DerefMut};
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::{CheckedSub, Error};
 
+use super::StoredU32;
+
 #[derive(
     Debug,
     PartialEq,
@@ -24,76 +27,88 @@ use crate::{CheckedSub, Error};
     KnownLayout,
     Serialize,
 )]
-pub struct Txindex(u32);
+pub struct TxIndex(u32);
+
+impl TxIndex {
+    pub const ZERO: Self = Self(0);
+
+    pub fn new(txindex: u32) -> Self {
+        Self(txindex)
+    }
 
-impl Txindex {
     pub fn incremented(self) -> Self {
         Self(*self + 1)
     }
 }
 
-impl Add<Txindex> for Txindex {
+impl Add<TxIndex> for TxIndex {
     type Output = Self;
-    fn add(self, rhs: Txindex) -> Self::Output {
+    fn add(self, rhs: TxIndex) -> Self::Output {
         Self(self.0 + rhs.0)
     }
 }
 
-impl Add<usize> for Txindex {
+impl Add<usize> for TxIndex {
     type Output = Self;
     fn add(self, rhs: usize) -> Self::Output {
         Self(self.0 + rhs as u32)
     }
 }
 
-impl AddAssign<Txindex> for Txindex {
-    fn add_assign(&mut self, rhs: Txindex) {
+impl AddAssign<TxIndex> for TxIndex {
+    fn add_assign(&mut self, rhs: TxIndex) {
         self.0 += rhs.0
     }
 }
 
-impl CheckedSub<Txindex> for Txindex {
-    fn checked_sub(self, rhs: Txindex) -> Option<Self> {
-        self.0.checked_sub(rhs.0).map(Txindex::from)
+impl CheckedSub<TxIndex> for TxIndex {
+    fn checked_sub(self, rhs: TxIndex) -> Option<Self> {
+        self.0.checked_sub(rhs.0).map(TxIndex::from)
     }
 }
 
-impl From<u32> for Txindex {
+impl From<u32> for TxIndex {
     fn from(value: u32) -> Self {
         Self(value)
     }
 }
 
-impl From<u64> for Txindex {
+impl From<u64> for TxIndex {
     fn from(value: u64) -> Self {
         Self(value as u32)
     }
 }
-impl From<Txindex> for u64 {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for u64 {
+    fn from(value: TxIndex) -> Self {
         value.0 as u64
     }
 }
 
-impl From<usize> for Txindex {
+impl From<usize> for TxIndex {
     fn from(value: usize) -> Self {
         Self(value as u32)
     }
 }
-impl From<Txindex> for usize {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for usize {
+    fn from(value: TxIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl TryFrom<ByteView> for Txindex {
+impl TryFrom<ByteView> for TxIndex {
     type Error = Error;
     fn try_from(value: ByteView) -> Result<Self, Self::Error> {
         Ok(Self::read_from_bytes(&value)?)
     }
 }
-impl From<Txindex> for ByteView {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for ByteView {
+    fn from(value: TxIndex) -> Self {
         Self::new(value.as_bytes())
     }
 }
+
+impl From<TxIndex> for StoredU32 {
+    fn from(value: TxIndex) -> Self {
+        Self::from(value.0)
+    }
+}

crates/brk_core/src/structs/txversion.rs

@@ -1,18 +1,52 @@
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
-pub struct TxVersion(i32);
+use super::StoredU8;
+
+#[derive(
+    Debug,
+    Deref,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    FromBytes,
+    Serialize,
+)]
+pub struct TxVersion(u8);
+
+impl TxVersion {
+    pub const ONE: Self = Self(1);
+    pub const TWO: Self = Self(2);
+    pub const THREE: Self = Self(3);
+    pub const NON_STANDARD: Self = Self(u8::MAX);
+}
 
 impl From<bitcoin::transaction::Version> for TxVersion {
     fn from(value: bitcoin::transaction::Version) -> Self {
-        Self(value.0)
+        match value.0 {
+            1 => Self::ONE,
+            2 => Self::TWO,
+            3 => Self::THREE,
+            _ => Self::NON_STANDARD,
+        }
     }
 }
 
 impl From<TxVersion> for bitcoin::transaction::Version {
     fn from(value: TxVersion) -> Self {
-        Self(value.0)
+        Self(value.0 as i32)
+    }
+}
+
+impl From<TxVersion> for StoredU8 {
+    fn from(value: TxVersion) -> Self {
+        Self::from(value.0)
     }
 }

crates/brk_core/src/structs/weekindex.rs

@@ -1,11 +1,11 @@
 use std::{fmt::Debug, ops::Add};
 
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex};
+use super::{Date, DateIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Weekindex(u16);
+pub struct WeekIndex(u16);
 
-impl From<u16> for Weekindex {
+impl From<u16> for WeekIndex {
     fn from(value: u16) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Weekindex {
+impl From<usize> for WeekIndex {
     fn from(value: usize) -> Self {
         Self(value as u16)
     }
 }
 
-impl From<Weekindex> for usize {
-    fn from(value: Weekindex) -> Self {
+impl From<WeekIndex> for usize {
+    fn from(value: WeekIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Weekindex {
+impl Add<usize> for WeekIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,13 +51,13 @@ impl Add<usize> for Weekindex {
     }
 }
 
-impl From<Dateindex> for Weekindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for WeekIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Weekindex {
+impl From<Date> for WeekIndex {
     fn from(value: Date) -> Self {
         let date = jiff::civil::Date::from(value).iso_week_date();
 
@@ -81,7 +81,7 @@ impl From<Date> for Weekindex {
     }
 }
 
-impl CheckedSub for Weekindex {
+impl CheckedSub for WeekIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }

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};
+use zerocopy_derive::{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 {
@@ -13,6 +29,45 @@ impl From<bitcoin::Weight> for Weight {
 
 impl From<Weight> for bitcoin::Weight {
     fn from(value: Weight) -> Self {
-        Self::from_wu(*value)
+        Self::from_wu(value.0)
+    }
+}
+
+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)
+    }
+}
+
+impl Div<Weight> for Weight {
+    type Output = Self;
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
     }
 }

crates/brk_core/src/structs/yearindex.rs

@@ -1,11 +1,11 @@
 use std::{fmt::Debug, ops::Add};
 
 use serde::{Deserialize, Serialize};
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Date, Dateindex, Monthindex};
+use super::{Date, DateIndex, MonthIndex};
 
 #[derive(
     Debug,
@@ -23,27 +23,27 @@ use super::{Date, Dateindex, Monthindex};
     IntoBytes,
     KnownLayout,
 )]
-pub struct Yearindex(u8);
+pub struct YearIndex(u8);
 
-impl From<u8> for Yearindex {
+impl From<u8> for YearIndex {
     fn from(value: u8) -> Self {
         Self(value)
     }
 }
 
-impl From<usize> for Yearindex {
+impl From<usize> for YearIndex {
     fn from(value: usize) -> Self {
         Self(value as u8)
     }
 }
 
-impl From<Yearindex> for usize {
-    fn from(value: Yearindex) -> Self {
+impl From<YearIndex> for usize {
+    fn from(value: YearIndex) -> Self {
         value.0 as usize
     }
 }
 
-impl Add<usize> for Yearindex {
+impl Add<usize> for YearIndex {
     type Output = Self;
 
     fn add(self, rhs: usize) -> Self::Output {
@@ -51,32 +51,32 @@ impl Add<usize> for Yearindex {
     }
 }
 
-impl From<Dateindex> for Yearindex {
-    fn from(value: Dateindex) -> Self {
+impl From<DateIndex> for YearIndex {
+    fn from(value: DateIndex) -> Self {
         Self::from(Date::from(value))
     }
 }
 
-impl From<Date> for Yearindex {
+impl From<Date> for YearIndex {
     fn from(value: Date) -> Self {
         Self((value.year() - 2009) as u8)
     }
 }
 
-impl From<Yearindex> for u16 {
-    fn from(value: Yearindex) -> Self {
+impl From<YearIndex> for u16 {
+    fn from(value: YearIndex) -> Self {
         value.0 as u16
     }
 }
 
-impl CheckedSub for Yearindex {
+impl CheckedSub for YearIndex {
     fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.0.checked_sub(rhs.0).map(Self)
     }
 }
 
-impl From<Monthindex> for Yearindex {
-    fn from(value: Monthindex) -> Self {
+impl From<MonthIndex> for YearIndex {
+    fn from(value: MonthIndex) -> Self {
         Self((usize::from(value) / 12) as u8)
     }
 }

crates/brk_core/src/utils/bytes.rs

@@ -0,0 +1,12 @@
+#[allow(clippy::result_unit_err)]
+pub fn copy_first_8bytes(slice: &[u8]) -> Result<[u8; 8], ()> {
+    let mut buf: [u8; 8] = [0; 8];
+    let buf_len = buf.len();
+    if slice.len() < buf_len {
+        return Err(());
+    }
+    slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
+        buf[i] = *r;
+    });
+    Ok(buf)
+}

crates/brk_core/src/utils/mod.rs

@@ -1,8 +1,10 @@
+mod bytes;
 mod checked_sub;
 mod paths;
 mod pause;
 mod rlimit;
 
+pub use bytes::*;
 pub use checked_sub::*;
 pub use paths::*;
 pub use pause::*;

crates/brk_exit/Cargo.toml

@@ -8,5 +8,5 @@ repository.workspace = true
 
 [dependencies]
 brk_logger = { workspace = true }
-ctrlc = { version = "3.4.5", features = ["termination"] }
+ctrlc = { version = "3.4.6", features = ["termination"] }
 log = { workspace = true }

crates/brk_exit/README.md

@@ -20,7 +20,7 @@
   <a href="https://deps.rs/crate/brk_exit">
     <img src="https://deps.rs/crate/brk_exit/latest/status.svg" alt="Dependency status">
   </a>
-  <a href="https://discord.gg/Cvrwpv3zEG">
+  <a href="https://discord.gg/HaR3wpH3nr">
     <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
   </a>
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_fetcher/README.md

@@ -20,7 +20,7 @@
   <a href="https://deps.rs/crate/brk_fetcher">
     <img src="https://deps.rs/crate/brk_fetcher/latest/status.svg" alt="Dependency status">
   </a>
-  <a href="https://discord.gg/Cvrwpv3zEG">
+  <a href="https://discord.gg/HaR3wpH3nr">
     <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
   </a>
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_fetcher/src/fetchers/binance.rs

@@ -82,7 +82,7 @@ impl Binance {
     }
 
     pub fn get_from_1d(&mut self, date: &Date) -> color_eyre::Result<OHLCCents> {
-        if self._1d.is_none() || self._1d.as_ref().unwrap().last_key_value().unwrap().0 < date {
+        if self._1d.is_none() || self._1d.as_ref().unwrap().last_key_value().unwrap().0 <= date {
             self._1d.replace(Self::fetch_1d()?);
         }
 
@@ -223,10 +223,10 @@ impl Binance {
         Ok((
             timestamp,
             OHLCCents::from((
-                Open::from(get_cents(1)),
-                High::from(get_cents(2)),
-                Low::from(get_cents(3)),
-                Close::from(get_cents(4)),
+                Open::new(get_cents(1)),
+                High::new(get_cents(2)),
+                Low::new(get_cents(3)),
+                Close::new(get_cents(4)),
             )),
         ))
     }

crates/brk_fetcher/src/fetchers/kibo.rs

@@ -81,7 +81,7 @@ impl Kibo {
                 .last_key_value()
                 .unwrap()
                 .0
-                < date
+                <= date
         {
             self.year_to_date_to_ohlc
                 .insert(year, Self::fetch_date_prices(year)?);
@@ -141,10 +141,10 @@ impl Kibo {
         };
 
         Ok(OHLCCents::from((
-            Open::from(get_value("open")?),
-            High::from(get_value("high")?),
-            Low::from(get_value("low")?),
-            Close::from(get_value("close")?),
+            Open::new(get_value("open")?),
+            High::new(get_value("high")?),
+            Low::new(get_value("low")?),
+            Close::new(get_value("close")?),
         )))
     }
 }

crates/brk_fetcher/src/fetchers/kraken.rs

@@ -43,7 +43,7 @@ impl Kraken {
     }
 
     pub fn get_from_1d(&mut self, date: &Date) -> color_eyre::Result<OHLCCents> {
-        if self._1d.is_none() || self._1d.as_ref().unwrap().last_key_value().unwrap().0 < date {
+        if self._1d.is_none() || self._1d.as_ref().unwrap().last_key_value().unwrap().0 <= date {
             self._1d.replace(Kraken::fetch_1d()?);
         }
         self._1d
@@ -114,10 +114,10 @@ impl Kraken {
         Ok((
             timestamp,
             OHLCCents::from((
-                Open::from(get_cents(1)),
-                High::from(get_cents(2)),
-                Low::from(get_cents(3)),
-                Close::from(get_cents(4)),
+                Open::new(get_cents(1)),
+                High::new(get_cents(2)),
+                Low::new(get_cents(3)),
+                Close::new(get_cents(4)),
             )),
         ))
     }

crates/brk_fetcher/src/lib.rs

@@ -60,9 +60,9 @@ impl Fetcher {
                 self.binance
                     .get_from_1mn(timestamp, previous_timestamp)
                     .unwrap_or_else(|_| {
-                        self.kibo.get_from_height(height).unwrap_or_else(|_| {
+                        self.kibo.get_from_height(height).unwrap_or_else(|e| {
                             let date = Date::from(timestamp);
-
+                            eprintln!("{e}");
                             panic!(
                                 "
 Can't find the price for: height: {height} - date: {date}

crates/brk_indexer/README.md

@@ -20,7 +20,7 @@
   <a href="https://deps.rs/crate/brk_indexer">
     <img src="https://deps.rs/crate/brk_indexer/latest/status.svg" alt="Dependency status">
   </a>
-  <a href="https://discord.gg/Cvrwpv3zEG">
+  <a href="https://discord.gg/HaR3wpH3nr">
     <img src="https://img.shields.io/discord/1350431684562124850?label=discord" alt="Discord" />
   </a>
   <a href="https://primal.net/p/nprofile1qqsfw5dacngjlahye34krvgz7u0yghhjgk7gxzl5ptm9v6n2y3sn03sqxu2e6">
@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>
@@ -58,9 +58,21 @@ Stores: `src/storage/stores/mod.rs`
 
 ## Benchmark
 
-Indexing `0..885_835` took `11 hours 6 min 50 s` on a Macbook Pro M3 Pro with 36 GB of RAM
+### `v0.0.21`
 
-`footprint` report:
-- Peak memory: `5115 MB`
-- Memory while waiting for a new block: `890 MB`
-- Reclaimable memory: `6478 MB`
+- machine: `MBP M3 Pro (36GB RAM)`
+- mode: `raw`
+- from: `0`
+- to: `892_098`
+- time: `7 hours 10 min 22s`
+- peak memory: `6.1GB`
+- disk usage: `270 GB`
+- overhead: `36%` (`270 GB / 741 GB`)
+
+### `v0.0.31`
+
+- machine: `MBP M3 Pro (36GB RAM)`
+- mode: `raw`
+- disk usage: `208 GB`
+- overhead: `28%` (`208 GB / 744 GB`)
+- peak memory: `5.7GB`

crates/brk_indexer/examples/main.rs

@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::{path::Path, time::Instant};
 
 use brk_core::default_bitcoin_path;
 use brk_exit::Exit;
@@ -8,6 +8,8 @@ use brk_parser::{Parser, rpc};
 fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
 
+    let i = Instant::now();
+
     brk_logger::init(Some(Path::new(".log")));
 
     let bitcoin_dir = default_bitcoin_path();
@@ -22,12 +24,14 @@ fn main() -> color_eyre::Result<()> {
 
     let outputs = Path::new("../../_outputs");
 
-    let mut indexer = Indexer::new(outputs.join("indexed").to_owned(), true, true)?;
+    let mut indexer = Indexer::new(outputs, false, false)?;
 
     indexer.import_stores()?;
     indexer.import_vecs()?;
 
     indexer.index(&parser, rpc, &exit)?;
 
+    dbg!(i.elapsed());
+
     Ok(())
 }

crates/brk_indexer/src/indexes.rs

@@ -1,56 +1,71 @@
 use bitcoincore_rpc::Client;
 use brk_core::{
-    Addressindex, BlockHash, CheckedSub, Emptyindex, Height, Multisigindex, Opreturnindex,
-    P2PK33index, P2PK65index, P2PKHindex, P2SHindex, P2TRindex, P2WPKHindex, P2WSHindex,
-    Pushonlyindex, Txindex, Txinindex, Txoutindex, Unknownindex,
+    BlockHash, CheckedSub, EmptyOutputIndex, Height, InputIndex, OpReturnIndex, OutputIndex,
+    OutputType, OutputTypeIndex, P2AIndex, P2MSIndex, P2PK33Index, P2PK65Index, P2PKHIndex,
+    P2SHIndex, P2TRIndex, P2WPKHIndex, P2WSHIndex, TxIndex, UnknownOutputIndex,
 };
 use brk_parser::NUMBER_OF_UNSAFE_BLOCKS;
+use brk_vec::{AnyIterableVec, AnyVec, IndexedVec, StoredIndex, StoredType};
 use color_eyre::eyre::ContextCompat;
 
 use crate::{Stores, Vecs};
 
 #[derive(Debug, Default, Clone)]
 pub struct Indexes {
-    pub addressindex: Addressindex,
-    pub emptyindex: Emptyindex,
+    pub emptyoutputindex: EmptyOutputIndex,
     pub height: Height,
-    pub multisigindex: Multisigindex,
-    pub opreturnindex: Opreturnindex,
-    pub p2pk33index: P2PK33index,
-    pub p2pk65index: P2PK65index,
-    pub p2pkhindex: P2PKHindex,
-    pub p2shindex: P2SHindex,
-    pub p2trindex: P2TRindex,
-    pub p2wpkhindex: P2WPKHindex,
-    pub p2wshindex: P2WSHindex,
-    pub pushonlyindex: Pushonlyindex,
-    pub txindex: Txindex,
-    pub txinindex: Txinindex,
-    pub txoutindex: Txoutindex,
-    pub unknownindex: Unknownindex,
+    pub opreturnindex: OpReturnIndex,
+    pub p2msindex: P2MSIndex,
+    pub p2pk33index: P2PK33Index,
+    pub p2pk65index: P2PK65Index,
+    pub p2pkhindex: P2PKHIndex,
+    pub p2shindex: P2SHIndex,
+    pub p2trindex: P2TRIndex,
+    pub p2wpkhindex: P2WPKHIndex,
+    pub p2wshindex: P2WSHIndex,
+    pub p2aindex: P2AIndex,
+    pub txindex: TxIndex,
+    pub inputindex: InputIndex,
+    pub outputindex: OutputIndex,
+    pub unknownoutputindex: UnknownOutputIndex,
 }
 
 impl Indexes {
+    pub fn outputtypeindex(&self, outputtype: OutputType) -> OutputTypeIndex {
+        match outputtype {
+            OutputType::Empty => *self.emptyoutputindex,
+            OutputType::OpReturn => *self.opreturnindex,
+            OutputType::P2A => *self.p2aindex,
+            OutputType::P2MS => *self.p2msindex,
+            OutputType::P2PK33 => *self.p2pkhindex,
+            OutputType::P2PK65 => *self.p2pk65index,
+            OutputType::P2PKH => *self.p2pkhindex,
+            OutputType::P2SH => *self.p2shindex,
+            OutputType::P2TR => *self.p2trindex,
+            OutputType::P2WPKH => *self.p2wpkhindex,
+            OutputType::P2WSH => *self.p2wshindex,
+            OutputType::Unknown => *self.unknownoutputindex,
+        }
+    }
+
     pub fn push_if_needed(&self, vecs: &mut Vecs) -> brk_vec::Result<()> {
         let height = self.height;
         vecs.height_to_first_txindex
             .push_if_needed(height, self.txindex)?;
-        vecs.height_to_first_txinindex
-            .push_if_needed(height, self.txinindex)?;
-        vecs.height_to_first_txoutindex
-            .push_if_needed(height, self.txoutindex)?;
-        vecs.height_to_first_addressindex
-            .push_if_needed(height, self.addressindex)?;
-        vecs.height_to_first_emptyindex
-            .push_if_needed(height, self.emptyindex)?;
-        vecs.height_to_first_multisigindex
-            .push_if_needed(height, self.multisigindex)?;
+        vecs.height_to_first_inputindex
+            .push_if_needed(height, self.inputindex)?;
+        vecs.height_to_first_outputindex
+            .push_if_needed(height, self.outputindex)?;
+        vecs.height_to_first_emptyoutputindex
+            .push_if_needed(height, self.emptyoutputindex)?;
+        vecs.height_to_first_p2msindex
+            .push_if_needed(height, self.p2msindex)?;
         vecs.height_to_first_opreturnindex
             .push_if_needed(height, self.opreturnindex)?;
-        vecs.height_to_first_pushonlyindex
-            .push_if_needed(height, self.pushonlyindex)?;
-        vecs.height_to_first_unknownindex
-            .push_if_needed(height, self.unknownindex)?;
+        vecs.height_to_first_p2aindex
+            .push_if_needed(height, self.p2aindex)?;
+        vecs.height_to_first_unknownoutputindex
+            .push_if_needed(height, self.unknownoutputindex)?;
         vecs.height_to_first_p2pk33index
             .push_if_needed(height, self.p2pk33index)?;
         vecs.height_to_first_p2pk65index
@@ -65,13 +80,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(())
     }
 }
@@ -98,45 +107,126 @@ impl TryFrom<(&mut Vecs, &Stores, &Client)> for Indexes {
                     })
                     .unwrap();
 
-                vecs.height_to_blockhash.get(*height).map_or(true, |opt| {
-                    opt.is_none_or(|saved_blockhash| {
+                vecs.height_to_blockhash
+                    .iter()
+                    .get(*height)
+                    .is_none_or(|saved_blockhash| {
                         let b = &rpc_blockhash != saved_blockhash.as_ref();
                         if b {
                             dbg!(rpc_blockhash, saved_blockhash.as_ref());
                         }
                         b
                     })
-                })
             })
             .unwrap_or(starting_height);
 
         Ok(Self {
-            addressindex: *vecs.height_to_first_addressindex.get(height)?.context("")?,
-            emptyindex: *vecs.height_to_first_emptyindex.get(height)?.context("")?,
+            emptyoutputindex: starting_index(
+                &vecs.height_to_first_emptyoutputindex,
+                &vecs.emptyoutputindex_to_txindex,
+                height,
+            )
+            .context("")?,
             height,
-            multisigindex: *vecs
-                .height_to_first_multisigindex
-                .get(height)?
+            p2msindex: starting_index(
+                &vecs.height_to_first_p2msindex,
+                &vecs.p2msindex_to_txindex,
+                height,
+            )
+            .context("")?,
+            opreturnindex: starting_index(
+                &vecs.height_to_first_opreturnindex,
+                &vecs.opreturnindex_to_txindex,
+                height,
+            )
+            .context("")?,
+            p2pk33index: starting_index(
+                &vecs.height_to_first_p2pk33index,
+                &vecs.p2pk33index_to_p2pk33bytes,
+                height,
+            )
+            .context("")?,
+            p2pk65index: starting_index(
+                &vecs.height_to_first_p2pk65index,
+                &vecs.p2pk65index_to_p2pk65bytes,
+                height,
+            )
+            .context("")?,
+            p2pkhindex: starting_index(
+                &vecs.height_to_first_p2pkhindex,
+                &vecs.p2pkhindex_to_p2pkhbytes,
+                height,
+            )
+            .context("")?,
+            p2shindex: starting_index(
+                &vecs.height_to_first_p2shindex,
+                &vecs.p2shindex_to_p2shbytes,
+                height,
+            )
+            .context("")?,
+            p2trindex: starting_index(
+                &vecs.height_to_first_p2trindex,
+                &vecs.p2trindex_to_p2trbytes,
+                height,
+            )
+            .context("")?,
+            p2wpkhindex: starting_index(
+                &vecs.height_to_first_p2wpkhindex,
+                &vecs.p2wpkhindex_to_p2wpkhbytes,
+                height,
+            )
+            .context("")?,
+            p2wshindex: starting_index(
+                &vecs.height_to_first_p2wshindex,
+                &vecs.p2wshindex_to_p2wshbytes,
+                height,
+            )
+            .context("")?,
+            p2aindex: starting_index(
+                &vecs.height_to_first_p2aindex,
+                &vecs.p2aindex_to_p2abytes,
+                height,
+            )
+            .context("")?,
+            txindex: starting_index(&vecs.height_to_first_txindex, &vecs.txindex_to_txid, height)
                 .context("")?,
-            opreturnindex: *vecs
-                .height_to_first_opreturnindex
-                .get(height)?
-                .context("")?,
-            p2pk33index: *vecs.height_to_first_p2pk33index.get(height)?.context("")?,
-            p2pk65index: *vecs.height_to_first_p2pk65index.get(height)?.context("")?,
-            p2pkhindex: *vecs.height_to_first_p2pkhindex.get(height)?.context("")?,
-            p2shindex: *vecs.height_to_first_p2shindex.get(height)?.context("")?,
-            p2trindex: *vecs.height_to_first_p2trindex.get(height)?.context("")?,
-            p2wpkhindex: *vecs.height_to_first_p2wpkhindex.get(height)?.context("")?,
-            p2wshindex: *vecs.height_to_first_p2wshindex.get(height)?.context("")?,
-            pushonlyindex: *vecs
-                .height_to_first_pushonlyindex
-                .get(height)?
-                .context("")?,
-            txindex: *vecs.height_to_first_txindex.get(height)?.context("")?,
-            txinindex: *vecs.height_to_first_txinindex.get(height)?.context("")?,
-            txoutindex: *vecs.height_to_first_txoutindex.get(height)?.context("")?,
-            unknownindex: *vecs.height_to_first_unknownindex.get(height)?.context("")?,
+            inputindex: starting_index(
+                &vecs.height_to_first_inputindex,
+                &vecs.inputindex_to_outputindex,
+                height,
+            )
+            .context("")?,
+            outputindex: starting_index(
+                &vecs.height_to_first_outputindex,
+                &vecs.outputindex_to_value,
+                height,
+            )
+            .context("")?,
+            unknownoutputindex: starting_index(
+                &vecs.height_to_first_unknownoutputindex,
+                &vecs.unknownoutputindex_to_txindex,
+                height,
+            )
+            .context("")?,
         })
     }
 }
+
+pub fn starting_index<I, T>(
+    height_to_index: &IndexedVec<Height, I>,
+    index_to_else: &IndexedVec<I, T>,
+    starting_height: Height,
+) -> Option<I>
+where
+    I: StoredType + StoredIndex + From<usize>,
+    T: StoredType,
+{
+    if height_to_index
+        .height()
+        .is_ok_and(|h| h + 1_u32 == starting_height)
+    {
+        Some(I::from(index_to_else.len()))
+    } else {
+        height_to_index.iter().get_inner(starting_height)
+    }
+}

crates/brk_indexer/src/lib.rs

@@ -11,16 +11,17 @@ use std::{
 };
 
 use brk_core::{
-    AddressHash, Addressbytes, Addressindex, Addresstype, BlockHash, BlockHashPrefix, Height, Sats,
-    Timestamp, Txid, TxidPrefix, Txindex, Txinindex, Txoutindex, Vin, Vout, setrlimit,
+    AddressBytes, AddressBytesHash, BlockHash, BlockHashPrefix, Height, InputIndex, OutputIndex,
+    OutputType, OutputTypeIndex, Sats, Timestamp, TxIndex, Txid, TxidPrefix, Vin, Vout, setrlimit,
 };
 pub use brk_parser::*;
 
 use bitcoin::{Transaction, TxIn, TxOut};
 use brk_exit::Exit;
-use brk_vec::Compressed;
+use brk_vec::{AnyVec, Compressed, VecIterator};
 use color_eyre::eyre::{ContextCompat, eyre};
-use log::info;
+use fjall::TransactionalKeyspace;
+use log::{error, info};
 use rayon::prelude::*;
 mod indexes;
 mod stores;
@@ -31,7 +32,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 = 893_000;
 
 #[derive(Clone)]
 pub struct Indexer {
@@ -44,13 +45,13 @@ pub struct Indexer {
 
 impl Indexer {
     pub fn new(
-        indexes_dir: PathBuf,
+        outputs_dir: &Path,
         compressed: bool,
         check_collisions: bool,
     ) -> color_eyre::Result<Self> {
         setrlimit()?;
         Ok(Self {
-            path: indexes_dir,
+            path: outputs_dir.to_owned(),
             vecs: None,
             stores: None,
             compressed: Compressed::from(compressed),
@@ -59,14 +60,17 @@ impl Indexer {
     }
 
     pub fn import_vecs(&mut self) -> color_eyre::Result<()> {
-        self.vecs = Some(Vecs::import(&self.path.join("vecs"), self.compressed)?);
+        self.vecs = Some(Vecs::forced_import(
+            &self.path.join("vecs/indexed"),
+            self.compressed,
+        )?);
         Ok(())
     }
 
     /// Do NOT import multiple times are things will break !!!
     /// Clone struct instead
     pub fn import_stores(&mut self) -> color_eyre::Result<()> {
-        self.stores = Some(Stores::import(&self.path.join("stores"))?);
+        self.stores = Some(Stores::forced_import(&self.path.join("stores"))?);
         Ok(())
     }
 
@@ -81,7 +85,7 @@ impl Indexer {
             self.stores.as_ref().unwrap(),
             rpc,
         ))
-        .unwrap_or_else(|_| {
+        .unwrap_or_else(|_report| {
             let indexes = Indexes::default();
             indexes.push_if_needed(self.vecs.as_mut().unwrap()).unwrap();
             indexes
@@ -101,6 +105,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);
@@ -145,24 +150,26 @@ impl Indexer {
                 let blockhash_prefix = BlockHashPrefix::from(&blockhash);
 
                 if stores
-                    .blockhash_prefix_to_height
+                    .blockhashprefix_to_height
                     .get(&blockhash_prefix)?
                     .is_some_and(|prev_height| *prev_height != height)
                 {
-                    dbg!(blockhash);
+                    error!("BlockHash: {blockhash}");
                     return Err(eyre!("Collision, expect prefix to need be set yet"));
                 }
 
+                idxs.push_if_needed(vecs)?;
+
                 stores
-                    .blockhash_prefix_to_height
+                    .blockhashprefix_to_height
                     .insert_if_needed(blockhash_prefix, height, height);
 
                 vecs.height_to_blockhash.push_if_needed(height, blockhash)?;
                 vecs.height_to_difficulty
-                    .push_if_needed(height, block.header.difficulty_float())?;
+                    .push_if_needed(height, block.header.difficulty_float().into())?;
                 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_total_size.push_if_needed(height, block.total_size().into())?;
                 vecs.height_to_weight.push_if_needed(height, block.weight().into())?;
 
                 let inputs = block
@@ -173,7 +180,7 @@ impl Indexer {
                         tx.input
                             .iter()
                             .enumerate()
-                            .map(move |(vin, txin)| (Txindex::from(index), Vin::from(vin), txin, tx))
+                            .map(move |(vin, txin)| (TxIndex::from(index), Vin::from(vin), txin, tx))
                     })
                     .collect::<Vec<_>>();
 
@@ -185,7 +192,7 @@ impl Indexer {
                         tx.output
                             .iter()
                             .enumerate()
-                            .map(move |(vout, txout)| (Txindex::from(index), Vout::from(vout), txout, tx))
+                            .map(move |(vout, txout)| (TxIndex::from(index), Vout::from(vout), txout, tx))
                     })
                     .collect::<Vec<_>>();
 
@@ -196,7 +203,7 @@ impl Indexer {
                 let (
                     txid_prefix_to_txid_and_block_txindex_and_prev_txindex_join_handle,
                     input_source_vec_handle,
-                    txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt_handle,
+                    outputindex_to_txout_outputtype_addressbytes_res_addressindex_opt_handle,
                 ) = thread::scope(|scope| {
                     let txid_prefix_to_txid_and_block_txindex_and_prev_txindex_handle =
                         scope.spawn(|| -> color_eyre::Result<_> {
@@ -210,14 +217,14 @@ impl Indexer {
                                     let txid_prefix = TxidPrefix::from(&txid);
 
                                     let prev_txindex_opt =
-                                        if check_collisions && stores.txid_prefix_to_txindex.needs(height) {
+                                        if check_collisions && stores.txidprefix_to_txindex.needs(height) {
                                             // Should only find collisions for two txids (duplicates), see below
-                                            stores.txid_prefix_to_txindex.get(&txid_prefix)?.map(|v| *v)
+                                            stores.txidprefix_to_txindex.get(&txid_prefix)?.map(|v| *v)
                                         } else {
                                             None
                                         };
 
-                                    Ok((txid_prefix, (tx, txid, Txindex::from(index), prev_txindex_opt)))
+                                    Ok((txid_prefix, (tx, txid, TxIndex::from(index), prev_txindex_opt)))
                                 })
                                 .try_fold(BTreeMap::new, |mut map, tuple| {
                                     let (key, value) = tuple?;
@@ -235,23 +242,27 @@ impl Indexer {
                                 })
                         });
 
+
                     let input_source_vec_handle = scope.spawn(|| {
+                        let txindex_to_first_outputindex_mmap = vecs
+                            .txindex_to_first_outputindex.mmap().load();
+
                         inputs
                             .into_par_iter()
                             .enumerate()
-                            .map(|(block_txinindex, (block_txindex, vin, txin, tx))| -> color_eyre::Result<(Txinindex, InputSource)> {
+                            .map(|(block_inputindex, (block_txindex, vin, txin, tx))| -> color_eyre::Result<(InputIndex, InputSource)> {
                                 let txindex = idxs.txindex + block_txindex;
-                                let txinindex = idxs.txinindex + Txinindex::from(block_txinindex);
+                                let inputindex = idxs.inputindex + InputIndex::from(block_inputindex);
 
                                 let outpoint = txin.previous_output;
                                 let txid = Txid::from(outpoint.txid);
 
                                 if tx.is_coinbase() {
-                                    return Ok((txinindex, InputSource::SameBlock((tx, txindex, txin, vin))));
+                                    return Ok((inputindex, InputSource::SameBlock((tx, txindex, txin, vin))));
                                 }
 
                                 let prev_txindex = if let Some(txindex) = stores
-                                    .txid_prefix_to_txindex
+                                    .txidprefix_to_txindex
                                     .get(&TxidPrefix::from(&txid))?
                                     .map(|v| *v)
                                     .and_then(|txindex| {
@@ -261,24 +272,22 @@ impl Indexer {
                                     txindex
                                 } else {
                                     // dbg!(indexes.txindex + block_txindex, txindex, txin, vin);
-                                    return Ok((txinindex, InputSource::SameBlock((tx, txindex, txin, vin))));
+                                    return Ok((inputindex, InputSource::SameBlock((tx, txindex, txin, vin))));
                                 };
 
                                 let vout = Vout::from(outpoint.vout);
 
-                                let txoutindex = *vecs
-                                    .txindex_to_first_txoutindex
-                                    .get(prev_txindex)?
-                                    .context("Expect txoutindex to not be none")
+                                let outputindex = vecs.txindex_to_first_outputindex.get_or_read(prev_txindex, &txindex_to_first_outputindex_mmap)?
+                                    .context("Expect outputindex to not be none")
                                     .inspect_err(|_| {
                                         dbg!(outpoint.txid, prev_txindex, vout);
-                                    })?
+                                    })?.into_inner()
                                     + vout;
 
-                                Ok((txinindex, InputSource::PreviousBlock((
+                                Ok((inputindex, InputSource::PreviousBlock((
                                     vin,
                                     txindex,
-                                    txoutindex,
+                                    outputindex,
                                 ))))
                             })
                             .try_fold(BTreeMap::new, |mut map, tuple| -> color_eyre::Result<_> {
@@ -297,71 +306,103 @@ impl Indexer {
                             })
                     });
 
-                    let txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt_handle = scope.spawn(|| {
+                    let outputindex_to_txout_outputtype_addressbytes_res_addressindex_opt_handle = scope.spawn(|| {
+                        let p2pk65index_to_p2pk65bytes_mmap = vecs
+                            .p2pk65index_to_p2pk65bytes.mmap().load();
+                        let p2pk33index_to_p2pk33bytes_mmap = vecs.p2pk33index_to_p2pk33bytes.mmap().load();
+                        let p2pkhindex_to_p2pkhbytes_mmap = vecs.p2pkhindex_to_p2pkhbytes.mmap().load();
+                        let p2shindex_to_p2shbytes_mmap = vecs.p2shindex_to_p2shbytes.mmap().load();
+                        let p2wpkhindex_to_p2wpkhbytes_mmap = vecs.p2wpkhindex_to_p2wpkhbytes.mmap().load();
+                        let p2wshindex_to_p2wshbytes_mmap = vecs.p2wshindex_to_p2wshbytes.mmap().load();
+                        let p2trindex_to_p2trbytes_mmap = vecs.p2trindex_to_p2trbytes.mmap().load();
+                       let p2aindex_to_p2abytes_mmap = vecs.p2aindex_to_p2abytes.mmap().load();
+
                         outputs
                             .into_par_iter()
                             .enumerate()
                             .map(
                                 #[allow(clippy::type_complexity)]
-                                |(block_txoutindex, (block_txindex, vout, txout, tx))| -> color_eyre::Result<(
-                                    Txoutindex,
+                                |(block_outputindex, (block_txindex, vout, txout, tx))| -> color_eyre::Result<(
+                                    OutputIndex,
                                     (
                                         &TxOut,
-                                        Txindex,
+                                        TxIndex,
                                         Vout,
-                                        Addresstype,
-                                        brk_core::Result<Addressbytes>,
-                                        Option<Addressindex>,
+                                        OutputType,
+                                        brk_core::Result<AddressBytes>,
+                                        Option<OutputTypeIndex>,
                                         &Transaction,
                                     ),
                                 )> {
                                     let txindex = idxs.txindex + block_txindex;
-                                    let txoutindex = idxs.txoutindex + Txoutindex::from(block_txoutindex);
+                                    let outputindex = idxs.outputindex + OutputIndex::from(block_outputindex);
 
                                     let script = &txout.script_pubkey;
 
-                                    let addresstype = Addresstype::from(script);
+                                    let outputtype = OutputType::from(script);
 
-                                    let addressbytes_res =
-                                        Addressbytes::try_from((script, addresstype)).inspect_err(|_| {
+                                    let address_bytes_res =
+                                        AddressBytes::try_from((script, outputtype)).inspect_err(|_| {
                                             // dbg!(&txout, height, txi, &tx.compute_txid());
                                         });
 
-                                    let addressindex_opt = addressbytes_res.as_ref().ok().and_then(|addressbytes| {
+                                    let outputtypeindex_opt = address_bytes_res.as_ref().ok().and_then(|addressbytes| {
                                         stores
-                                            .addresshash_to_addressindex
-                                            .get(&AddressHash::from((addressbytes, addresstype)))
+                                            .addressbyteshash_to_outputtypeindex
+                                            .get(&AddressBytesHash::from((addressbytes, outputtype)))
                                             .unwrap()
                                             .map(|v| *v)
                                             // Checking if not in the future
-                                            .and_then(|addressindex_local| {
-                                                (addressindex_local < idxs.addressindex).then_some(addressindex_local)
+                                            .and_then(|outputtypeindex_local| {
+                                                (outputtypeindex_local < idxs.outputtypeindex(outputtype)).then_some(outputtypeindex_local)
                                             })
                                     });
 
-                                    if let Some(Some(addressindex)) = check_collisions.then_some(addressindex_opt) {
-                                        let addressbytes = addressbytes_res.as_ref().unwrap();
-
-                                        let prev_addresstype = *vecs
-                                            .addressindex_to_addresstype
-                                            .get(addressindex)?
-                                            .context("Expect to have address type")?;
-
-                                        let addresstypeindex = *vecs
-                                            .addressindex_to_addresstypeindex
-                                            .get(addressindex)?
-                                            .context("Expect to have address type index")?;
-
-                                        let prev_addressbytes_opt =
-                                            vecs.get_addressbytes(prev_addresstype, addresstypeindex)?;
+                                    if let Some(Some(outputtypeindex)) = check_collisions.then_some(outputtypeindex_opt) {
+                                        let addressbytes = address_bytes_res.as_ref().unwrap();
 
+                                        let prev_addressbytes_opt = match outputtype {
+                                            OutputType::P2PK65 => vecs
+                                                .p2pk65index_to_p2pk65bytes
+                                                .get_or_read(outputtypeindex.into(), &p2pk65index_to_p2pk65bytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::P2PK33 => vecs
+                                                .p2pk33index_to_p2pk33bytes
+                                                .get_or_read(outputtypeindex.into(), &p2pk33index_to_p2pk33bytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::P2PKH => vecs
+                                                .p2pkhindex_to_p2pkhbytes
+                                                .get_or_read(outputtypeindex.into(), &p2pkhindex_to_p2pkhbytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::P2SH => vecs
+                                                .p2shindex_to_p2shbytes
+                                                .get_or_read(outputtypeindex.into(), &p2shindex_to_p2shbytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::P2WPKH => vecs
+                                                .p2wpkhindex_to_p2wpkhbytes
+                                                .get_or_read(outputtypeindex.into(), &p2wpkhindex_to_p2wpkhbytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::P2WSH => vecs
+                                                .p2wshindex_to_p2wshbytes
+                                                .get_or_read(outputtypeindex.into(), &p2wshindex_to_p2wshbytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::P2TR => vecs
+                                                .p2trindex_to_p2trbytes
+                                                .get_or_read(outputtypeindex.into(), &p2trindex_to_p2trbytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::P2A => vecs
+                                                .p2aindex_to_p2abytes
+                                                .get_or_read(outputtypeindex.into(), &p2aindex_to_p2abytes_mmap)?
+                                                .map(|v| AddressBytes::from(v.into_inner())),
+                                            OutputType::Empty | OutputType::OpReturn | OutputType::P2MS | OutputType::Unknown => {
+                                                unreachable!()
+                                            }
+                                        };
                                         let prev_addressbytes =
                                             prev_addressbytes_opt.as_ref().context("Expect to have addressbytes")?;
 
-                                        if (vecs.addressindex_to_addresstype.hasnt(addressindex)?
-                                            && addresstype != prev_addresstype)
-                                            || (stores.addresshash_to_addressindex.needs(height)
-                                                && prev_addressbytes != addressbytes)
+                                        if stores.addressbyteshash_to_outputtypeindex.needs(height)
+                                                && prev_addressbytes != addressbytes
                                         {
                                             let txid = tx.compute_txid();
                                             dbg!(
@@ -369,30 +410,28 @@ impl Indexer {
                                                 txid,
                                                 vout,
                                                 block_txindex,
-                                                addresstype,
-                                                prev_addresstype,
+                                                outputtype,
                                                 prev_addressbytes,
                                                 addressbytes,
-                                                idxs.addressindex,
-                                                addressindex,
-                                                addresstypeindex,
+                                                &idxs,
+                                                outputtypeindex,
+                                                outputtypeindex,
                                                 txout,
-                                                AddressHash::from((addressbytes, addresstype)),
-                                                AddressHash::from((prev_addressbytes, prev_addresstype))
+                                                AddressBytesHash::from((addressbytes, outputtype)),
                                             );
                                             panic!()
                                         }
                                     }
 
                                     Ok((
-                                        txoutindex,
+                                        outputindex,
                                         (
                                             txout,
                                             txindex,
                                             vout,
-                                            addresstype,
-                                            addressbytes_res,
-                                            addressindex_opt,
+                                            outputtype,
+                                            address_bytes_res,
+                                            outputtypeindex_opt,
                                             tx,
                                         ),
                                     ))
@@ -417,7 +456,7 @@ impl Indexer {
                     (
                         txid_prefix_to_txid_and_block_txindex_and_prev_txindex_handle.join(),
                         input_source_vec_handle.join(),
-                        txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt_handle.join(),
+                        outputindex_to_txout_outputtype_addressbytes_res_addressindex_opt_handle.join(),
                     )
                 });
 
@@ -432,118 +471,139 @@ impl Indexer {
                     .ok()
                     .context("Export input_source_vec_handle to join")??;
 
-                let txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt =
-                    txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt_handle
+                let outputindex_to_txout_outputtype_addressbytes_res_addressindex_opt =
+                    outputindex_to_txout_outputtype_addressbytes_res_addressindex_opt_handle
                         .ok()
                         .context(
-                            "Expect txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt_handle to join",
+                            "Expect outputindex_to_txout_outputtype_addressbytes_res_addressindex_opt_handle to join",
                         )??;
 
-                let mut new_txindexvout_to_txoutindex: BTreeMap<
-                    (Txindex, Vout),
-                    Txoutindex,
+                let mut new_txindexvout_to_outputindex: BTreeMap<
+                    (TxIndex, Vout),
+                    OutputIndex,
                 > = BTreeMap::new();
 
-                let mut already_added_addresshash: BTreeMap<AddressHash, Addressindex> = BTreeMap::new();
+                let mut already_added_addressbyteshash: BTreeMap<AddressBytesHash, OutputTypeIndex> = BTreeMap::new();
 
-                txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt
+                outputindex_to_txout_outputtype_addressbytes_res_addressindex_opt
                 .into_iter()
                 .try_for_each(
                     |(
-                        txoutindex,
-                        (txout, txindex, vout, addresstype, addressbytes_res, addressindex_opt, _tx),
+                        outputindex,
+                        (txout, txindex, vout, outputtype, addressbytes_res, outputtypeindex_opt, _tx),
                     )|
                      -> color_eyre::Result<()> {
                         let sats = Sats::from(txout.value);
 
                         if vout.is_zero() {
-                            vecs.txindex_to_first_txoutindex.push_if_needed(txindex, txoutindex)?;
+                            vecs.txindex_to_first_outputindex.push_if_needed(txindex, outputindex)?;
                         }
 
-                        vecs.txoutindex_to_value.push_if_needed(txoutindex, sats)?;
+                        vecs.outputindex_to_value.push_if_needed(outputindex, sats)?;
 
-                        let mut addressindex = idxs.addressindex;
+                        vecs.outputindex_to_outputtype
+                            .push_if_needed(outputindex, outputtype)?;
 
-                        let mut addresshash = None;
+                        let mut addressbyteshash = None;
 
-                        if let Some(addressindex_local) = addressindex_opt.or_else(|| {
+                        let outputtypeindex;
+
+                        if let Some(outputtypeindex_local) = outputtypeindex_opt.or_else(|| {
                             addressbytes_res.as_ref().ok().and_then(|addressbytes| {
                                 // Check if address was first seen before in this iterator
                                 // Example: https://mempool.space/address/046a0765b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0c
-                                addresshash.replace(AddressHash::from((addressbytes, addresstype)));
-                                already_added_addresshash
-                                    .get(addresshash.as_ref().unwrap())
+                                addressbyteshash.replace(AddressBytesHash::from((addressbytes, outputtype)));
+                                already_added_addressbyteshash
+                                    .get(addressbyteshash.as_ref().unwrap())
                                     .cloned()
                             })
                         }) {
-                            addressindex = addressindex_local;
+                            outputtypeindex = outputtypeindex_local;
                         } else {
-                            idxs.addressindex.increment();
-
-                            let addresstypeindex = match addresstype {
-                                Addresstype::Empty => idxs.emptyindex.copy_then_increment(),
-                                Addresstype::Multisig => idxs.multisigindex.copy_then_increment(),
-                                Addresstype::OpReturn => idxs.opreturnindex.copy_then_increment(),
-                                Addresstype::PushOnly => idxs.pushonlyindex.copy_then_increment(),
-                                Addresstype::Unknown => idxs.unknownindex.copy_then_increment(),
-                                Addresstype::P2PK65 => idxs.p2pk65index.copy_then_increment(),
-                                Addresstype::P2PK33 => idxs.p2pk33index.copy_then_increment(),
-                                Addresstype::P2PKH => idxs.p2pkhindex.copy_then_increment(),
-                                Addresstype::P2SH => idxs.p2shindex.copy_then_increment(),
-                                Addresstype::P2WPKH => idxs.p2wpkhindex.copy_then_increment(),
-                                Addresstype::P2WSH => idxs.p2wshindex.copy_then_increment(),
-                                Addresstype::P2TR => idxs.p2trindex.copy_then_increment(),
+                            outputtypeindex = match outputtype {
+                                OutputType::P2PK65 => {
+                                    idxs.p2pk65index.copy_then_increment()
+                                },
+                                OutputType::P2PK33 => {
+                                    idxs.p2pk33index.copy_then_increment()
+                                },
+                                OutputType::P2PKH => {
+                                    idxs.p2pkhindex.copy_then_increment()
+                                },
+                                OutputType::P2MS => {
+                                    vecs.p2msindex_to_txindex.push_if_needed(idxs.p2msindex, txindex)?;
+                                    idxs.p2msindex.copy_then_increment()
+                                },
+                                OutputType::P2SH => {
+                                    idxs.p2shindex.copy_then_increment()
+                                },
+                                OutputType::OpReturn => {
+                                    vecs.opreturnindex_to_txindex.push_if_needed(idxs.opreturnindex, txindex)?;
+                                    idxs.opreturnindex.copy_then_increment()
+                                },
+                                OutputType::P2WPKH => {
+                                    idxs.p2wpkhindex.copy_then_increment()
+                                },
+                                OutputType::P2WSH => {
+                                    idxs.p2wshindex.copy_then_increment()
+                                },
+                                OutputType::P2TR => {
+                                    idxs.p2trindex.copy_then_increment()
+                                },
+                                OutputType::P2A => {
+                                    idxs.p2aindex.copy_then_increment()
+                                },
+                                OutputType::Empty => {
+                                    vecs.emptyoutputindex_to_txindex
+                                        .push_if_needed(idxs.emptyoutputindex, txindex)?;
+                                    idxs.emptyoutputindex.copy_then_increment()
+                                },
+                                OutputType::Unknown => {
+                                    vecs.unknownoutputindex_to_txindex.push_if_needed(idxs.unknownoutputindex, txindex)?;
+                                    idxs.unknownoutputindex.copy_then_increment()
+                                },
                             };
 
-                            vecs.addressindex_to_addresstype
-                                .push_if_needed(addressindex, addresstype)?;
-
-                            vecs.addressindex_to_addresstypeindex
-                                .push_if_needed(addressindex, addresstypeindex)?;
-
-                            vecs.addressindex_to_height
-                                .push_if_needed(addressindex, height)?;
-
                             if let Ok(addressbytes) = addressbytes_res {
-                                let addresshash = addresshash.unwrap();
+                                let addressbyteshash = addressbyteshash.unwrap();
 
-                                already_added_addresshash
-                                    .insert(addresshash, addressindex);
+                                already_added_addressbyteshash
+                                    .insert(addressbyteshash, outputtypeindex);
 
-                                stores.addresshash_to_addressindex.insert_if_needed(
-                                    addresshash,
-                                    addressindex,
+                                stores.addressbyteshash_to_outputtypeindex.insert_if_needed(
+                                    addressbyteshash,
+                                    outputtypeindex,
                                     height,
                                 );
 
-                                vecs.push_addressbytes_if_needed(addresstypeindex, addressbytes)?;
+                                vecs.push_bytes_if_needed(outputtypeindex, addressbytes)?;
                             }
                         }
 
-                        new_txindexvout_to_txoutindex
-                            .insert((txindex, vout), txoutindex);
+                        vecs.outputindex_to_outputtypeindex
+                            .push_if_needed(outputindex, outputtypeindex)?;
 
-                        vecs.txoutindex_to_addressindex
-                            .push_if_needed(txoutindex, addressindex)?;
+                        new_txindexvout_to_outputindex
+                            .insert((txindex, vout), outputindex);
 
                         Ok(())
                     },
                 )?;
 
-                drop(already_added_addresshash);
+                drop(already_added_addressbyteshash);
 
                 input_source_vec
                     .into_iter()
                     .map(
                         #[allow(clippy::type_complexity)]
-                        |(txinindex, input_source)| -> color_eyre::Result<(
-                            Txinindex, Vin, Txindex, Txoutindex
+                        |(inputindex, input_source)| -> color_eyre::Result<(
+                            InputIndex, Vin, TxIndex, OutputIndex
                         )> {
                             match input_source {
-                                InputSource::PreviousBlock((vin, txindex, txoutindex)) => Ok((txinindex, vin, txindex, txoutindex)),
+                                InputSource::PreviousBlock((vin, txindex, outputindex)) => Ok((inputindex, vin, txindex, outputindex)),
                                 InputSource::SameBlock((tx, txindex, txin, vin)) => {
                                     if tx.is_coinbase() {
-                                        return Ok((txinindex, vin, txindex, Txoutindex::COINBASE));
+                                        return Ok((inputindex, vin, txindex, OutputIndex::COINBASE));
                                     }
 
                                     let outpoint = txin.previous_output;
@@ -559,33 +619,36 @@ impl Indexer {
                                         .2;
                                     let prev_txindex = idxs.txindex + block_txindex;
 
-                                    let prev_txoutindex = new_txindexvout_to_txoutindex
+                                    let prev_outputindex = new_txindexvout_to_outputindex
                                         .remove(&(prev_txindex, vout))
                                         .context("should have found addressindex from same block")
                                         .inspect_err(|_| {
-                                            dbg!(&new_txindexvout_to_txoutindex, txin, prev_txindex, vout, txid);
+                                            dbg!(&new_txindexvout_to_outputindex, txin, prev_txindex, vout, txid);
                                         })?;
 
-                                    Ok((txinindex, vin, txindex, prev_txoutindex))
+                                    Ok((inputindex, vin, txindex, prev_outputindex))
                                 }
                             }
                         },
                     )
                     .try_for_each(|res| -> color_eyre::Result<()> {
-                        let (txinindex, vin, txindex, txoutindex) = res?;
+                        let (inputindex, vin, txindex, outputindex) = res?;
 
                         if vin.is_zero() {
-                            vecs.txindex_to_first_txinindex.push_if_needed(txindex, txinindex)?;
+                            vecs.txindex_to_first_inputindex.push_if_needed(txindex, inputindex)?;
                         }
 
-                        vecs.txinindex_to_txoutindex.push_if_needed(txinindex, txoutindex)?;
+                        vecs.inputindex_to_outputindex.push_if_needed(inputindex, outputindex)?;
 
                         Ok(())
                     })?;
 
-                drop(new_txindexvout_to_txoutindex);
+                drop(new_txindexvout_to_outputindex);
 
-                let mut txindex_to_tx_and_txid: BTreeMap<Txindex, (&Transaction, Txid)> = BTreeMap::default();
+                let mut txindex_to_tx_and_txid: BTreeMap<TxIndex, (&Transaction, Txid)> = BTreeMap::default();
+
+                let mut txindex_to_txid_iter = vecs
+                    .txindex_to_txid.into_iter();
 
                 txid_prefix_to_txid_and_block_txindex_and_prev_txindex
                     .into_iter()
@@ -598,7 +661,7 @@ impl Indexer {
                             match prev_txindex_opt {
                                 None => {
                                     stores
-                                        .txid_prefix_to_txindex
+                                        .txidprefix_to_txindex
                                         .insert_if_needed(txid_prefix, txindex, height);
                                 }
                                 Some(prev_txindex) => {
@@ -608,14 +671,13 @@ impl Indexer {
                                     }
 
                                     if !check_collisions {
-                                        return Ok(())
+                                        return Ok(());
                                     }
 
                                     let len = vecs.txindex_to_txid.len();
                                     // Ok if `get` is not par as should happen only twice
-                                    let prev_txid = vecs
-                                        .txindex_to_txid
-                                        .get(prev_txindex)?
+                                    let prev_txid = txindex_to_txid_iter
+                                        .get(prev_txindex)
                                         .context("To have txid for txindex")
                                         .inspect_err(|_| {
                                             dbg!(txindex, len);
@@ -639,9 +701,7 @@ impl Indexer {
                                     let is_dup = only_known_dup_txids.contains(prev_txid);
 
                                     if !is_dup {
-                                        let prev_height =
-                                            vecs.txindex_to_height.get(prev_txindex)?.expect("To have height");
-                                        dbg!(height, txindex, prev_height, prev_txid, prev_txindex);
+                                        dbg!(height, txindex, prev_txid, prev_txindex);
                                         return Err(eyre!("Expect none"));
                                     }
                                 }
@@ -656,19 +716,16 @@ impl Indexer {
                     .try_for_each(|(txindex, (tx, txid))| -> color_eyre::Result<()> {
                         vecs.txindex_to_txversion.push_if_needed(txindex, tx.version.into())?;
                         vecs.txindex_to_txid.push_if_needed(txindex, txid)?;
-                        vecs.txindex_to_height.push_if_needed(txindex, height)?;
-                        vecs.txindex_to_locktime.push_if_needed(txindex, tx.lock_time.into())?;
-                        vecs.txindex_to_base_size.push_if_needed(txindex, tx.base_size())?;
-                        vecs.txindex_to_total_size.push_if_needed(txindex, tx.total_size())?;
+                        vecs.txindex_to_rawlocktime.push_if_needed(txindex, tx.lock_time.into())?;
+                        vecs.txindex_to_base_size.push_if_needed(txindex, tx.base_size().into())?;
+                        vecs.txindex_to_total_size.push_if_needed(txindex, tx.total_size().into())?;
                         vecs.txindex_to_is_explicitly_rbf.push_if_needed(txindex, tx.is_explicitly_rbf())?;
                         Ok(())
                     })?;
 
-                idxs.txindex += Txindex::from(tx_len);
-                idxs.txinindex += Txinindex::from(inputs_len);
-                idxs.txoutindex += Txoutindex::from(outputs_len);
-
-                idxs.push_future_if_needed(vecs)?;
+                idxs.txindex += TxIndex::from(tx_len);
+                idxs.inputindex += InputIndex::from(inputs_len);
+                idxs.outputindex += OutputIndex::from(outputs_len);
 
                 export_if_needed(stores, vecs, height, false, exit)?;
 
@@ -683,10 +740,6 @@ impl Indexer {
         Ok(starting_indexes)
     }
 
-    pub fn path(&self) -> &Path {
-        &self.path
-    }
-
     pub fn vecs(&self) -> &Vecs {
         self.vecs.as_ref().unwrap()
     }
@@ -702,10 +755,14 @@ impl Indexer {
     pub fn mut_stores(&mut self) -> &mut Stores {
         self.stores.as_mut().unwrap()
     }
+
+    pub fn keyspace(&self) -> &TransactionalKeyspace {
+        &self.stores().keyspace
+    }
 }
 
 #[derive(Debug)]
 enum InputSource<'a> {
-    PreviousBlock((Vin, Txindex, Txoutindex)),
-    SameBlock((&'a Transaction, Txindex, &'a TxIn, Vin)),
+    PreviousBlock((Vin, TxIndex, OutputIndex)),
+    SameBlock((&'a Transaction, TxIndex, &'a TxIn, Vin)),
 }

crates/brk_indexer/src/stores/base.rs

@@ -19,14 +19,16 @@ use super::StoreMeta;
 
 pub struct Store<Key, Value> {
     meta: StoreMeta,
+    name: String,
     keyspace: TransactionalKeyspace,
-    part: TransactionalPartitionHandle,
+    partition: TransactionalPartitionHandle,
     rtx: ReadTransaction,
     puts: BTreeMap<Key, Value>,
     dels: BTreeSet<Key>,
 }
 
 const CHECK_COLLISISONS: bool = true;
+const MAJOR_FJALL_VERSION: Version = Version::TWO;
 
 impl<K, V> Store<K, V>
 where
@@ -34,34 +36,32 @@ where
     V: Debug + Clone + Into<ByteView> + TryFrom<ByteView>,
     <V as TryFrom<ByteView>>::Error: error::Error + Send + Sync + 'static,
 {
-    pub fn import(path: &Path, version: Version) -> color_eyre::Result<Self> {
-        let meta = StoreMeta::checked_open(path, version)?;
+    pub fn import(
+        keyspace: TransactionalKeyspace,
+        path: &Path,
+        name: &str,
+        version: Version,
+    ) -> color_eyre::Result<Self> {
+        let version = MAJOR_FJALL_VERSION + version;
 
-        let keyspace = match Self::open_keyspace(path) {
-            Ok(keyspace) => keyspace,
-            Err(e) => {
-                dbg!(e);
-                meta.reset()?;
-                return Self::import(path, version);
-            }
-        };
-
-        let part = match Self::open_partition_handle(&keyspace) {
-            Ok(part) => part,
-            Err(e) => {
-                dbg!(e);
-                drop(keyspace);
-                meta.reset()?;
-                return Self::import(path, version);
-            }
-        };
+        let (meta, partition) = StoreMeta::checked_open(
+            &keyspace,
+            &path.join(format!("meta/{name}")),
+            version,
+            || {
+                Self::open_partition_handle(&keyspace, name).inspect_err(|_| {
+                    eprintln!("Delete {path:?} and try again");
+                })
+            },
+        )?;
 
         let rtx = keyspace.read_tx();
 
         Ok(Self {
             meta,
+            name: name.to_owned(),
             keyspace,
-            part,
+            partition,
             rtx,
             puts: BTreeMap::new(),
             dels: BTreeSet::new(),
@@ -71,7 +71,7 @@ where
     pub fn get(&self, key: &K) -> color_eyre::Result<Option<Value<V>>> {
         if let Some(v) = self.puts.get(key) {
             Ok(Some(Value::Ref(v)))
-        } else if let Some(slice) = self.rtx.get(&self.part, key.as_bytes())? {
+        } else if let Some(slice) = self.rtx.get(&self.partition, key.as_bytes())? {
             Ok(Some(Value::Owned(V::try_from(slice.as_bytes().into())?)))
         } else {
             Ok(None)
@@ -89,12 +89,16 @@ where
     }
 
     pub fn remove(&mut self, key: K) {
+        if self.is_empty() {
+            return;
+        }
+
         if !self.puts.is_empty() {
             unreachable!("Shouldn't reach this");
-            // self.puts.remove(&key);
         }
-        // dbg!(&key);
-        if !self.dels.insert(key) {
+
+        if !self.dels.insert(key.clone()) {
+            dbg!(key, &self.meta.path());
             unreachable!();
         }
     }
@@ -110,25 +114,25 @@ where
 
         mem::take(&mut self.dels)
             .into_iter()
-            .for_each(|key| wtx.remove(&self.part, key.as_bytes()));
+            .for_each(|key| wtx.remove(&self.partition, key.as_bytes()));
 
         mem::take(&mut self.puts)
             .into_iter()
             .for_each(|(key, value)| {
                 if CHECK_COLLISISONS {
                     #[allow(unused_must_use)]
-                    if let Ok(Some(value)) = wtx.get(&self.part, key.as_bytes()) {
+                    if let Ok(Some(value)) = wtx.get(&self.partition, key.as_bytes()) {
                         dbg!(
                             &key,
                             V::try_from(value.as_bytes().into()).unwrap(),
                             &self.meta,
-                            self.rtx.get(&self.part, key.as_bytes())
+                            self.rtx.get(&self.partition, key.as_bytes())
                         );
                         unreachable!();
                     }
                 }
                 wtx.insert(
-                    &self.part,
+                    &self.partition,
                     key.as_bytes(),
                     &*ByteView::try_from(value).unwrap(),
                 )
@@ -136,15 +140,13 @@ where
 
         wtx.commit()?;
 
-        self.keyspace.persist(PersistMode::SyncAll)?;
-
         self.rtx = self.keyspace.read_tx();
 
         Ok(())
     }
 
     pub fn rotate_memtable(&self) {
-        let _ = self.part.inner().rotate_memtable();
+        let _ = self.partition.inner().rotate_memtable();
     }
 
     pub fn height(&self) -> Option<Height> {
@@ -165,23 +167,25 @@ where
         self.meta.needs(height)
     }
 
-    fn open_keyspace(path: &Path) -> Result<TransactionalKeyspace> {
-        fjall::Config::new(path.join("fjall"))
-            .max_write_buffer_size(32 * 1024 * 1024)
-            .open_transactional()
-    }
-
     fn open_partition_handle(
         keyspace: &TransactionalKeyspace,
+        name: &str,
     ) -> Result<TransactionalPartitionHandle> {
         keyspace.open_partition(
-            "partition",
+            name,
             PartitionCreateOptions::default()
                 .bloom_filter_bits(Some(5))
                 .max_memtable_size(8 * 1024 * 1024)
                 .manual_journal_persist(true),
         )
     }
+
+    pub fn reset_partition(&mut self) -> Result<()> {
+        self.keyspace.delete_partition(self.partition.clone())?;
+        self.keyspace.persist(PersistMode::SyncAll)?;
+        self.partition = Self::open_partition_handle(&self.keyspace, &self.name)?;
+        Ok(())
+    }
 }
 
 impl<Key, Value> Clone for Store<Key, Value>
@@ -192,8 +196,9 @@ where
     fn clone(&self) -> Self {
         Self {
             meta: self.meta.clone(),
+            name: self.name.clone(),
             keyspace: self.keyspace.clone(),
-            part: self.part.clone(),
+            partition: self.partition.clone(),
             rtx: self.keyspace.read_tx(),
             puts: self.puts.clone(),
             dels: self.dels.clone(),

crates/brk_indexer/src/stores/meta.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use brk_vec::Version;
+use fjall::{TransactionalKeyspace, TransactionalPartitionHandle};
 use zerocopy::{FromBytes, IntoBytes};
 
 use super::Height;
@@ -17,14 +18,27 @@ pub struct StoreMeta {
 }
 
 impl StoreMeta {
-    pub fn checked_open(path: &Path, version: Version) -> color_eyre::Result<Self> {
+    pub fn checked_open<F>(
+        keyspace: &TransactionalKeyspace,
+        path: &Path,
+        version: Version,
+        open_partition_handle: F,
+    ) -> color_eyre::Result<(Self, TransactionalPartitionHandle)>
+    where
+        F: Fn() -> fjall::Result<TransactionalPartitionHandle>,
+    {
         fs::create_dir_all(path)?;
 
         let is_same_version = Version::try_from(Self::path_version_(path).as_path())
             .is_ok_and(|prev_version| version == prev_version);
 
+        let mut partition = open_partition_handle()?;
+
         if !is_same_version {
             Self::reset_(path)?;
+            keyspace.delete_partition(partition)?;
+            keyspace.persist(fjall::PersistMode::SyncAll)?;
+            partition = open_partition_handle()?;
         }
 
         let slf = Self {
@@ -36,7 +50,7 @@ impl StoreMeta {
 
         slf.version.write(&slf.path_version())?;
 
-        Ok(slf)
+        Ok((slf, partition))
     }
 
     pub fn len(&self) -> usize {
@@ -46,6 +60,10 @@ impl StoreMeta {
         self.len() == 0
     }
 
+    pub fn version(&self) -> Version {
+        self.version
+    }
+
     pub fn export(&mut self, len: usize, height: Height) -> io::Result<()> {
         self.len = len;
         self.write_length()?;
@@ -61,6 +79,10 @@ impl StoreMeta {
         fs::create_dir(path)
     }
 
+    pub fn path(&self) -> &Path {
+        &self.pathbuf
+    }
+
     fn path_version(&self) -> PathBuf {
         Self::path_version_(&self.pathbuf)
     }

crates/brk_indexer/src/stores/mod.rs

@@ -1,10 +1,11 @@
-use std::{path::Path, thread};
+use std::{fs, path::Path, thread};
 
 use brk_core::{
-    AddressHash, Addressbytes, Addressindex, Addresstype, BlockHashPrefix, Height, TxidPrefix,
-    Txindex,
+    AddressBytes, AddressBytesHash, BlockHashPrefix, Height, OutputType, OutputTypeIndex, TxIndex,
+    TxidPrefix,
 };
-use brk_vec::{Value, Version};
+use brk_vec::{AnyIterableVec, Value, Version};
+use fjall::{PersistMode, TransactionalKeyspace};
 
 use crate::Indexes;
 
@@ -18,27 +19,57 @@ use super::Vecs;
 
 #[derive(Clone)]
 pub struct Stores {
-    pub addresshash_to_addressindex: Store<AddressHash, Addressindex>,
-    pub blockhash_prefix_to_height: Store<BlockHashPrefix, Height>,
-    pub txid_prefix_to_txindex: Store<TxidPrefix, Txindex>,
+    pub keyspace: TransactionalKeyspace,
+    pub addressbyteshash_to_outputtypeindex: Store<AddressBytesHash, OutputTypeIndex>,
+    pub blockhashprefix_to_height: Store<BlockHashPrefix, Height>,
+    pub txidprefix_to_txindex: Store<TxidPrefix, TxIndex>,
 }
 
 impl Stores {
-    pub fn import(path: &Path) -> color_eyre::Result<Self> {
+    pub fn forced_import(path: &Path) -> color_eyre::Result<Self> {
+        fs::create_dir_all(path)?;
+
+        let keyspace = match Self::open_keyspace(path) {
+            Ok(keyspace) => keyspace,
+            Err(_) => {
+                fs::remove_dir_all(path)?;
+                return Self::forced_import(path);
+            }
+        };
+
         thread::scope(|scope| {
-            let addresshash_to_addressindex = scope.spawn(|| {
-                Store::import(&path.join("addresshash_to_addressindex"), Version::from(1))
+            let addressbyteshash_to_outputtypeindex = scope.spawn(|| {
+                Store::import(
+                    keyspace.clone(),
+                    path,
+                    "addressbyteshash_to_outputtypeindex",
+                    Version::ZERO,
+                )
             });
-            let blockhash_prefix_to_height = scope.spawn(|| {
-                Store::import(&path.join("blockhash_prefix_to_height"), Version::from(1))
+            let blockhashprefix_to_height = scope.spawn(|| {
+                Store::import(
+                    keyspace.clone(),
+                    path,
+                    "blockhashprefix_to_height",
+                    Version::ZERO,
+                )
+            });
+            let txidprefix_to_txindex = scope.spawn(|| {
+                Store::import(
+                    keyspace.clone(),
+                    path,
+                    "txidprefix_to_txindex",
+                    Version::ZERO,
+                )
             });
-            let txid_prefix_to_txindex = scope
-                .spawn(|| Store::import(&path.join("txid_prefix_to_txindex"), Version::from(1)));
 
             Ok(Self {
-                addresshash_to_addressindex: addresshash_to_addressindex.join().unwrap()?,
-                blockhash_prefix_to_height: blockhash_prefix_to_height.join().unwrap()?,
-                txid_prefix_to_txindex: txid_prefix_to_txindex.join().unwrap()?,
+                keyspace: keyspace.clone(),
+                addressbyteshash_to_outputtypeindex: addressbyteshash_to_outputtypeindex
+                    .join()
+                    .unwrap()?,
+                blockhashprefix_to_height: blockhashprefix_to_height.join().unwrap()?,
+                txidprefix_to_txindex: txidprefix_to_txindex.join().unwrap()?,
             })
         })
     }
@@ -48,137 +79,196 @@ impl Stores {
         vecs: &mut Vecs,
         starting_indexes: &Indexes,
     ) -> color_eyre::Result<()> {
-        vecs.height_to_blockhash
-            .iter_from(starting_indexes.height, |(_, blockhash, ..)| {
-                let blockhash_prefix = BlockHashPrefix::from(blockhash);
-                self.blockhash_prefix_to_height.remove(blockhash_prefix);
-                Ok(())
-            })?;
-
-        vecs.txindex_to_txid
-            .iter_from(starting_indexes.txindex, |(_txindex, txid, ..)| {
-                let txid_prefix = TxidPrefix::from(txid);
-                self.txid_prefix_to_txindex.remove(txid_prefix);
-                Ok(())
-            })?;
-
-        if let Some(index) = vecs
-            .height_to_first_p2pk65index
-            .get(starting_indexes.height)?
+        if self.addressbyteshash_to_outputtypeindex.is_empty()
+            && self.blockhashprefix_to_height.is_empty()
+            && self.txidprefix_to_txindex.is_empty()
         {
-            let mut index = index.into_inner();
-            while let Some(typedbytes) = vecs
-                .p2pk65index_to_p2pk65addressbytes
-                .get(index)?
-                .map(Value::into_inner)
-            {
-                let bytes = Addressbytes::from(typedbytes);
-                let hash = AddressHash::from((&bytes, Addresstype::P2PK65));
-                self.addresshash_to_addressindex.remove(hash);
-                index.increment();
-            }
+            return Ok(());
         }
 
-        if let Some(index) = vecs
-            .height_to_first_p2pk33index
-            .get(starting_indexes.height)?
-        {
-            let mut index = index.into_inner();
-            while let Some(typedbytes) = vecs
-                .p2pk33index_to_p2pk33addressbytes
-                .get(index)?
+        if starting_indexes.height != Height::ZERO {
+            vecs.height_to_blockhash
+                .iter_at(starting_indexes.height)
+                .for_each(|(_, v)| {
+                    let blockhashprefix = BlockHashPrefix::from(Value::into_inner(v));
+                    self.blockhashprefix_to_height.remove(blockhashprefix);
+                });
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2pk65index
+                .iter()
+                .get(starting_indexes.height)
                 .map(Value::into_inner)
             {
-                let bytes = Addressbytes::from(typedbytes);
-                let hash = AddressHash::from((&bytes, Addresstype::P2PK33));
-                self.addresshash_to_addressindex.remove(hash);
-                index.increment();
+                let mut p2pk65index_to_p2pk65bytes_iter = vecs.p2pk65index_to_p2pk65bytes.iter();
+
+                while let Some(typedbytes) = p2pk65index_to_p2pk65bytes_iter
+                    .get(index)
+                    .map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2PK65));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
             }
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2pk33index
+                .iter()
+                .get(starting_indexes.height)
+                .map(Value::into_inner)
+            {
+                let mut p2pk33index_to_p2pk33bytes_iter = vecs.p2pk33index_to_p2pk33bytes.iter();
+
+                while let Some(typedbytes) = p2pk33index_to_p2pk33bytes_iter
+                    .get(index)
+                    .map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2PK33));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
+            }
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2pkhindex
+                .iter()
+                .get(starting_indexes.height)
+                .map(Value::into_inner)
+            {
+                let mut p2pkhindex_to_p2pkhbytes_iter = vecs.p2pkhindex_to_p2pkhbytes.iter();
+
+                while let Some(typedbytes) = p2pkhindex_to_p2pkhbytes_iter
+                    .get(index)
+                    .map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2PKH));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
+            }
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2shindex
+                .iter()
+                .get(starting_indexes.height)
+                .map(Value::into_inner)
+            {
+                let mut p2shindex_to_p2shbytes_iter = vecs.p2shindex_to_p2shbytes.iter();
+
+                while let Some(typedbytes) = p2shindex_to_p2shbytes_iter
+                    .get(index)
+                    .map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2SH));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
+            }
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2trindex
+                .iter()
+                .get(starting_indexes.height)
+                .map(Value::into_inner)
+            {
+                let mut p2trindex_to_p2trbytes_iter = vecs.p2trindex_to_p2trbytes.iter();
+
+                while let Some(typedbytes) = p2trindex_to_p2trbytes_iter
+                    .get(index)
+                    .map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2TR));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
+            }
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2wpkhindex
+                .iter()
+                .get(starting_indexes.height)
+                .map(Value::into_inner)
+            {
+                let mut p2wpkhindex_to_p2wpkhbytes_iter = vecs.p2wpkhindex_to_p2wpkhbytes.iter();
+
+                while let Some(typedbytes) = p2wpkhindex_to_p2wpkhbytes_iter
+                    .get(index)
+                    .map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2WPKH));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
+            }
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2wshindex
+                .iter()
+                .get(starting_indexes.height)
+                .map(Value::into_inner)
+            {
+                let mut p2wshindex_to_p2wshbytes_iter = vecs.p2wshindex_to_p2wshbytes.iter();
+
+                while let Some(typedbytes) = p2wshindex_to_p2wshbytes_iter
+                    .get(index)
+                    .map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2WSH));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
+            }
+
+            if let Some(mut index) = vecs
+                .height_to_first_p2aindex
+                .iter()
+                .get(starting_indexes.height)
+                .map(Value::into_inner)
+            {
+                let mut p2aindex_to_p2abytes_iter = vecs.p2aindex_to_p2abytes.iter();
+
+                while let Some(typedbytes) =
+                    p2aindex_to_p2abytes_iter.get(index).map(Value::into_inner)
+                {
+                    let bytes = AddressBytes::from(typedbytes);
+                    let hash = AddressBytesHash::from((&bytes, OutputType::P2A));
+                    self.addressbyteshash_to_outputtypeindex.remove(hash);
+                    index.increment();
+                }
+            }
+        } else {
+            self.blockhashprefix_to_height.reset_partition()?;
+            self.addressbyteshash_to_outputtypeindex.reset_partition()?;
         }
 
-        if let Some(index) = vecs
-            .height_to_first_p2pkhindex
-            .get(starting_indexes.height)?
-        {
-            let mut index = index.into_inner();
-            while let Some(typedbytes) = vecs
-                .p2pkhindex_to_p2pkhaddressbytes
-                .get(index)?
-                .map(Value::into_inner)
-            {
-                let bytes = Addressbytes::from(typedbytes);
-                let hash = AddressHash::from((&bytes, Addresstype::P2PKH));
-                self.addresshash_to_addressindex.remove(hash);
-                index.increment();
-            }
-        }
+        if starting_indexes.txindex != TxIndex::ZERO {
+            vecs.txindex_to_txid
+                .iter_at(starting_indexes.txindex)
+                .for_each(|(txindex, txid)| {
+                    let txidprefix = TxidPrefix::from(&txid.into_inner());
 
-        if let Some(index) = vecs
-            .height_to_first_p2shindex
-            .get(starting_indexes.height)?
-        {
-            let mut index = index.into_inner();
-            while let Some(typedbytes) = vecs
-                .p2shindex_to_p2shaddressbytes
-                .get(index)?
-                .map(Value::into_inner)
-            {
-                let bytes = Addressbytes::from(typedbytes);
-                let hash = AddressHash::from((&bytes, Addresstype::P2SH));
-                self.addresshash_to_addressindex.remove(hash);
-                index.increment();
-            }
-        }
+                    // "d5d27987d2a3dfc724e359870c6644b40e497bdc0589a033220fe15429d88599"
+                    let is_not_first_dup = txindex != TxIndex::new(142783)
+                        || txidprefix != TxidPrefix::from([153, 133, 216, 41, 84, 225, 15, 34]);
 
-        if let Some(index) = vecs
-            .height_to_first_p2trindex
-            .get(starting_indexes.height)?
-        {
-            let mut index = index.into_inner();
-            while let Some(typedbytes) = vecs
-                .p2trindex_to_p2traddressbytes
-                .get(index)?
-                .map(Value::into_inner)
-            {
-                let bytes = Addressbytes::from(typedbytes);
-                let hash = AddressHash::from((&bytes, Addresstype::P2TR));
-                self.addresshash_to_addressindex.remove(hash);
-                index.increment();
-            }
-        }
+                    // "e3bf3d07d4b0375638d5f1db5255fe07ba2c4cb067cd81b84ee974b6585fb468"
+                    let is_not_second_dup = txindex != TxIndex::new(142841)
+                        || txidprefix != TxidPrefix::from([104, 180, 95, 88, 182, 116, 233, 78]);
 
-        if let Some(index) = vecs
-            .height_to_first_p2wpkhindex
-            .get(starting_indexes.height)?
-        {
-            let mut index = index.into_inner();
-            while let Some(typedbytes) = vecs
-                .p2wpkhindex_to_p2wpkhaddressbytes
-                .get(index)?
-                .map(Value::into_inner)
-            {
-                let bytes = Addressbytes::from(typedbytes);
-                let hash = AddressHash::from((&bytes, Addresstype::P2WPKH));
-                self.addresshash_to_addressindex.remove(hash);
-                index.increment();
-            }
-        }
-
-        if let Some(index) = vecs
-            .height_to_first_p2wshindex
-            .get(starting_indexes.height)?
-        {
-            let mut index = index.into_inner();
-            while let Some(typedbytes) = vecs
-                .p2wshindex_to_p2wshaddressbytes
-                .get(index)?
-                .map(Value::into_inner)
-            {
-                let bytes = Addressbytes::from(typedbytes);
-                let hash = AddressHash::from((&bytes, Addresstype::P2WSH));
-                self.addresshash_to_addressindex.remove(hash);
-                index.increment();
-            }
+                    if is_not_first_dup && is_not_second_dup {
+                        self.txidprefix_to_txindex.remove(txidprefix);
+                    }
+                });
+        } else {
+            self.txidprefix_to_txindex.reset_partition()?;
         }
 
         self.commit(starting_indexes.height.decremented().unwrap_or_default())?;
@@ -188,9 +278,9 @@ impl Stores {
 
     pub fn starting_height(&self) -> Height {
         [
-            self.addresshash_to_addressindex.height(),
-            self.blockhash_prefix_to_height.height(),
-            self.txid_prefix_to_txindex.height(),
+            self.addressbyteshash_to_outputtypeindex.height(),
+            self.blockhashprefix_to_height.height(),
+            self.txidprefix_to_txindex.height(),
         ]
         .into_iter()
         .map(|height| height.map(Height::incremented).unwrap_or_default())
@@ -199,25 +289,35 @@ impl Stores {
     }
 
     pub fn commit(&mut self, height: Height) -> fjall::Result<()> {
-        thread::scope(|scope| {
-            let addresshash_to_addressindex_commit_handle =
-                scope.spawn(|| self.addresshash_to_addressindex.commit(height));
-            let blockhash_prefix_to_height_commit_handle =
-                scope.spawn(|| self.blockhash_prefix_to_height.commit(height));
-            let txid_prefix_to_txindex_commit_handle =
-                scope.spawn(|| self.txid_prefix_to_txindex.commit(height));
+        thread::scope(|scope| -> fjall::Result<()> {
+            let addressbyteshash_to_outputtypeindex_commit_handle =
+                scope.spawn(|| self.addressbyteshash_to_outputtypeindex.commit(height));
+            let blockhashprefix_to_height_commit_handle =
+                scope.spawn(|| self.blockhashprefix_to_height.commit(height));
+            let txidprefix_to_txindex_commit_handle =
+                scope.spawn(|| self.txidprefix_to_txindex.commit(height));
 
-            addresshash_to_addressindex_commit_handle.join().unwrap()?;
-            blockhash_prefix_to_height_commit_handle.join().unwrap()?;
-            txid_prefix_to_txindex_commit_handle.join().unwrap()?;
+            addressbyteshash_to_outputtypeindex_commit_handle
+                .join()
+                .unwrap()?;
+            blockhashprefix_to_height_commit_handle.join().unwrap()?;
+            txidprefix_to_txindex_commit_handle.join().unwrap()?;
 
             Ok(())
-        })
+        })?;
+
+        self.keyspace.persist(PersistMode::SyncAll)
     }
 
     pub fn rotate_memtables(&self) {
-        self.addresshash_to_addressindex.rotate_memtable();
-        self.blockhash_prefix_to_height.rotate_memtable();
-        self.txid_prefix_to_txindex.rotate_memtable();
+        self.addressbyteshash_to_outputtypeindex.rotate_memtable();
+        self.blockhashprefix_to_height.rotate_memtable();
+        self.txidprefix_to_txindex.rotate_memtable();
+    }
+
+    fn open_keyspace(path: &Path) -> fjall::Result<TransactionalKeyspace> {
+        fjall::Config::new(path.join("fjall"))
+            .max_write_buffer_size(32 * 1024 * 1024)
+            .open_transactional()
     }
 }

crates/brk_indexer/src/vecs/base.rs

@@ -1,195 +0,0 @@
-use std::{
-    cmp::Ordering,
-    fmt::Debug,
-    io,
-    path::{Path, PathBuf},
-};
-
-use brk_vec::{
-    AnyStorableVec, Compressed, Error, MAX_CACHE_SIZE, MAX_PAGE_SIZE, Result, StoredIndex,
-    StoredType, Value, Version,
-};
-
-use super::Height;
-
-#[derive(Debug)]
-pub struct StorableVec<I, T> {
-    height: Option<Height>,
-    vec: brk_vec::StorableVec<I, T>,
-}
-
-impl<I, T> StorableVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    pub const SIZE_OF_T: usize = size_of::<T>();
-    pub const PER_PAGE: usize = MAX_PAGE_SIZE / Self::SIZE_OF_T;
-    pub const PAGE_SIZE: usize = Self::PER_PAGE * Self::SIZE_OF_T;
-    pub const CACHE_LENGTH: usize = MAX_CACHE_SIZE / Self::PAGE_SIZE;
-
-    pub fn forced_import(
-        path: &Path,
-        version: Version,
-        compressed: Compressed,
-    ) -> brk_vec::Result<Self> {
-        let mut vec = brk_vec::StorableVec::forced_import(path, version, compressed)?;
-
-        vec.enable_large_cache();
-
-        Ok(Self {
-            height: Height::try_from(Self::path_height_(path).as_path()).ok(),
-            vec,
-        })
-    }
-
-    #[inline]
-    pub fn get(&self, index: I) -> Result<Option<Value<'_, T>>> {
-        self.get_(index.to_usize()?)
-    }
-    fn get_(&self, index: usize) -> Result<Option<Value<'_, T>>> {
-        match self.vec.index_to_pushed_index(index) {
-            Ok(index) => {
-                if let Some(index) = index {
-                    return Ok(self.vec.pushed().get(index).map(|v| Value::Ref(v)));
-                }
-            }
-            Err(Error::IndexTooHigh) => return Ok(None),
-            Err(Error::IndexTooLow) => {}
-            Err(error) => return Err(error),
-        }
-
-        let large_cache_len = self.vec.large_cache_len();
-        if large_cache_len != 0 {
-            let page_index = Self::index_to_page_index(index);
-            let last_index = self.vec.stored_len() - 1;
-            let max_page_index = Self::index_to_page_index(last_index);
-            let min_page_index = (max_page_index + 1) - large_cache_len;
-
-            if page_index >= min_page_index {
-                let values = self
-                    .vec
-                    .pages()
-                    .unwrap()
-                    .get(page_index - min_page_index)
-                    .ok_or(Error::MmapsVecIsTooSmall)?
-                    .get_or_init(|| self.vec.decode_page(page_index).unwrap());
-
-                return Ok(values.get(index)?.map(|v| Value::Ref(v)));
-            }
-        }
-
-        Ok(self.vec.read_(index)?.map(|v| Value::Owned(v)))
-    }
-
-    pub fn iter_from<F>(&mut self, index: I, f: F) -> Result<()>
-    where
-        F: FnMut((I, &T)) -> Result<()>,
-    {
-        self.vec.iter_from(index, f)
-    }
-
-    #[inline(always)]
-    fn index_to_page_index(index: usize) -> usize {
-        index / Self::PER_PAGE
-    }
-
-    #[inline]
-    pub fn push_if_needed(&mut self, index: I, value: T) -> Result<()> {
-        match self.vec.len().cmp(&index.to_usize()?) {
-            Ordering::Greater => {
-                // dbg!(len, index, &self.pathbuf);
-                // panic!();
-                Ok(())
-            }
-            Ordering::Equal => {
-                self.vec.push(value);
-                Ok(())
-            }
-            Ordering::Less => {
-                dbg!(index, value);
-                Err(Error::IndexTooHigh)
-            }
-        }
-    }
-
-    pub fn truncate_if_needed(&mut self, index: I, height: Height) -> brk_vec::Result<()> {
-        if self.height.is_none_or(|self_height| self_height != height) {
-            height.write(&self.path_height())?;
-        }
-        self.vec.truncate_if_needed(index)?;
-        Ok(())
-    }
-
-    pub fn flush(&mut self, height: Height) -> io::Result<()> {
-        height.write(&self.path_height())?;
-        self.vec.flush()
-    }
-
-    pub fn vec(&self) -> &brk_vec::StorableVec<I, T> {
-        &self.vec
-    }
-
-    pub fn mut_vec(&mut self) -> &mut brk_vec::StorableVec<I, T> {
-        &mut self.vec
-    }
-
-    pub fn any_vec(&self) -> &dyn AnyStorableVec {
-        &self.vec
-    }
-
-    pub fn len(&self) -> usize {
-        self.vec.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.vec.is_empty()
-    }
-
-    #[inline]
-    pub fn hasnt(&self, index: I) -> Result<bool> {
-        self.vec.has(index).map(|b| !b)
-    }
-
-    pub fn height(&self) -> brk_core::Result<Height> {
-        Height::try_from(self.path_height().as_path())
-    }
-    fn path_height(&self) -> PathBuf {
-        Self::path_height_(self.vec.path())
-    }
-    fn path_height_(path: &Path) -> PathBuf {
-        path.join("height")
-    }
-}
-
-impl<I, T> Clone for StorableVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    fn clone(&self) -> Self {
-        Self {
-            height: self.height,
-            vec: self.vec.clone(),
-        }
-    }
-}
-
-pub trait AnyIndexedVec: Send + Sync {
-    fn height(&self) -> brk_core::Result<Height>;
-    fn flush(&mut self, height: Height) -> io::Result<()>;
-}
-
-impl<I, T> AnyIndexedVec for StorableVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    fn height(&self) -> brk_core::Result<Height> {
-        self.height()
-    }
-
-    fn flush(&mut self, height: Height) -> io::Result<()> {
-        self.flush(height)
-    }
-}