website: redesign part 34

.github/workflows/outdated.yml

@@ -1,15 +0,0 @@
-name: Check outdated dependencies
-
-on:
-  schedule:
-    - cron: "0 9 * * 1"
-  workflow_dispatch:
-
-jobs:
-  outdated:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - run: cargo install cargo-outdated
-      - run: cargo outdated --exit-code 1 --depth 1

.github/workflows/release.yml

@@ -1,296 +0,0 @@
-# This file was autogenerated by dist: https://axodotdev.github.io/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-22.04"
-    outputs:
-      val: ${{ steps.plan.outputs.manifest }}
-      tag: ${{ !github.event.pull_request && github.ref_name || '' }}
-      tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
-      publishing: ${{ !github.event.pull_request }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install dist
-        # we specify bash to get pipefail; it guards against the `curl` command
-        # failing. otherwise `sh` won't catch that `curl` returned non-0
-        shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.30.2/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:
-          persist-credentials: false
-          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-22.04"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install cached dist
-        uses: actions/download-artifact@v4
-        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 plan, local and global didn't fail (skipped is fine)
-    if: ${{ always() && needs.plan.result == 'success' && 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-22.04"
-    outputs:
-      val: ${{ steps.host.outputs.manifest }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install cached dist
-        uses: actions/download-artifact@v4
-        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-22.04"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-          submodules: recursive

.gitignore

@@ -18,6 +18,7 @@ _*
 /*.py
 /*.json
 /*.html
+!/btc-cycle-sim.html
 /research
 /filter_*
 /heatmaps*

CLAUDE.md

@@ -1 +0,0 @@
-Codex will review your output once you are done.

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.3.0-beta.8"
+package.version = "0.3.4"
 package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 package.readme = "README.md"
@@ -28,9 +28,6 @@ lto = false
 strip = false
 inherits = "release"
 
-[profile.dist]
-inherits = "release"
-
 [profile.profiling]
 inherits = "release"
 debug = true
@@ -38,51 +35,51 @@ debug = true
 [workspace.dependencies]
 aide = { version = "0.16.0-alpha.4", features = ["axum-json", "axum-query"] }
 axum = { version = "0.8.9", default-features = false, features = ["http1", "json", "query", "tokio", "tracing"] }
-bitcoin = { version = "0.32.9", features = ["serde"] }
-brk_alloc = { version = "0.3.0-beta.8", path = "crates/brk_alloc" }
-brk_bencher = { version = "0.3.0-beta.8", path = "crates/brk_bencher" }
-brk_bindgen = { version = "0.3.0-beta.8", path = "crates/brk_bindgen" }
-brk_cli = { version = "0.3.0-beta.8", path = "crates/brk_cli" }
-brk_client = { version = "0.3.0-beta.8", path = "crates/brk_client" }
-brk_cohort = { version = "0.3.0-beta.8", path = "crates/brk_cohort" }
-brk_computer = { version = "0.3.0-beta.8", path = "crates/brk_computer" }
-brk_error = { version = "0.3.0-beta.8", path = "crates/brk_error" }
-brk_fetcher = { version = "0.3.0-beta.8", path = "crates/brk_fetcher" }
-brk_indexer = { version = "0.3.0-beta.8", path = "crates/brk_indexer" }
-brk_iterator = { version = "0.3.0-beta.8", path = "crates/brk_iterator" }
-brk_logger = { version = "0.3.0-beta.8", path = "crates/brk_logger" }
-brk_mempool = { version = "0.3.0-beta.8", path = "crates/brk_mempool" }
-brk_oracle = { version = "0.3.0-beta.8", path = "crates/brk_oracle" }
-brk_query = { version = "0.3.0-beta.8", path = "crates/brk_query", features = ["tokio"] }
-brk_reader = { version = "0.3.0-beta.8", path = "crates/brk_reader" }
-brk_rpc = { version = "0.3.0-beta.8", path = "crates/brk_rpc" }
-brk_server = { version = "0.3.0-beta.8", path = "crates/brk_server" }
-brk_store = { version = "0.3.0-beta.8", path = "crates/brk_store" }
-brk_traversable = { version = "0.3.0-beta.8", path = "crates/brk_traversable", features = ["pco", "derive"] }
-brk_traversable_derive = { version = "0.3.0-beta.8", path = "crates/brk_traversable_derive" }
-brk_types = { version = "0.3.0-beta.8", path = "crates/brk_types" }
-brk_website = { version = "0.3.0-beta.8", path = "crates/brk_website" }
+bitcoin = { version = "0.32.10", features = ["serde"] }
+brk_alloc = { version = "0.3.4", path = "crates/brk_alloc" }
+brk_bencher = { version = "0.3.4", path = "crates/brk_bencher" }
+brk_bindgen = { version = "0.3.4", path = "crates/brk_bindgen" }
+brk_cli = { version = "0.3.4", path = "crates/brk_cli" }
+brk_client = { version = "0.3.4", path = "crates/brk_client" }
+brk_cohort = { version = "0.3.4", path = "crates/brk_cohort" }
+brk_computer = { version = "0.3.4", path = "crates/brk_computer" }
+brk_error = { version = "0.3.4", path = "crates/brk_error" }
+brk_fetcher = { version = "0.3.4", path = "crates/brk_fetcher" }
+brk_indexer = { version = "0.3.4", path = "crates/brk_indexer" }
+brk_iterator = { version = "0.3.4", path = "crates/brk_iterator" }
+brk_logger = { version = "0.3.4", path = "crates/brk_logger" }
+brk_mempool = { version = "0.3.4", path = "crates/brk_mempool" }
+brk_oracle = { version = "0.3.4", path = "crates/brk_oracle" }
+brk_query = { version = "0.3.4", path = "crates/brk_query", features = ["tokio"] }
+brk_reader = { version = "0.3.4", path = "crates/brk_reader" }
+brk_rpc = { version = "0.3.4", path = "crates/brk_rpc" }
+brk_server = { version = "0.3.4", path = "crates/brk_server" }
+brk_store = { version = "0.3.4", path = "crates/brk_store" }
+brk_traversable = { version = "0.3.4", path = "crates/brk_traversable", features = ["pco", "derive"] }
+brk_traversable_derive = { version = "0.3.4", path = "crates/brk_traversable_derive" }
+brk_types = { version = "0.3.4", path = "crates/brk_types" }
+brk_website = { version = "0.3.4", path = "crates/brk_website" }
 byteview = "0.10.1"
 color-eyre = "0.6.5"
 corepc-jsonrpc = { package = "jsonrpc", version = "0.19.0", features = ["simple_http"], default-features = false }
-corepc-types = { version = "0.12.0", features = ["std"], default-features = false }
+corepc-types = { version = "0.15.0", features = ["std"], default-features = false }
 derive_more = { version = "2.1.1", features = ["deref", "deref_mut"] }
-fjall = "=3.0.4"
+fjall = "3.1.5"
 indexmap = { version = "2.14.0", features = ["serde"] }
-jiff = { version = "0.2.24", features = ["perf-inline", "tz-system"], default-features = false }
+jiff = { version = "0.2.29", features = ["perf-inline", "tz-system"], default-features = false }
 owo-colors = "4.3.0"
 parking_lot = "0.12.5"
-pco = "1.0.1"
+pco = "1.0.2"
 rayon = "1.12.0"
 rustc-hash = "2.1.2"
 schemars = { version = "1.2.1", features = ["indexmap2"] }
 serde = "1.0.228"
 serde_bytes = "0.11.19"
 serde_derive = "1.0.228"
-serde_json = { version = "1.0.149", features = ["float_roundtrip", "preserve_order"] }
-smallvec = "1.15.1"
-tokio = { version = "1.52.2", features = ["rt-multi-thread"] }
-tower-http = { version = "0.6.10", features = ["catch-panic", "compression-br", "compression-gzip", "compression-zstd", "cors", "normalize-path", "timeout", "trace"] }
+serde_json = { version = "1.0.150", features = ["float_roundtrip", "preserve_order"] }
+smallvec = "1.15.2"
+tokio = { version = "1.52.3", features = ["rt-multi-thread"] }
+tower-http = { version = "0.7.0", features = ["catch-panic", "compression-br", "compression-gzip", "compression-zstd", "cors", "normalize-path", "timeout", "trace"] }
 tower-layer = "0.3"
 tracing = { version = "0.1", default-features = false, features = ["std"] }
 ureq = { version = "3.3.0", features = ["json"] }
@@ -95,10 +92,3 @@ tag-name = "v{{version}}"
 pre-release-commit-message = "release: v{{version}}"
 tag-message = "release: v{{version}}"
 allow-branch = ["main", "next"]
-
-[workspace.metadata.dist]
-cargo-dist-version = "0.30.2"
-ci = "github"
-allow-dirty = ["ci"]
-installers = []
-targets = ["aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"]

LICENSE

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

crates/blk/Cargo.toml

@@ -13,7 +13,7 @@ brk_error = { workspace = true }
 brk_reader = { workspace = true }
 brk_rpc = { workspace = true }
 brk_types = { workspace = true }
-owo-colors = { workspace = true }
+owo-colors = { workspace = true, features = ["supports-colors"] }
 serde_json = { workspace = true }
 
 [[bin]]

crates/blk/src/args.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{collections::HashSet, path::PathBuf};
 
 use brk_error::{Error, Result};
 use brk_rpc::{Auth, Client};
@@ -66,6 +66,9 @@ impl Args {
                 }
                 continue;
             }
+            if a.starts_with('-') {
+                return Err(Error::Parse(format!("unknown flag {a}")));
+            }
             positional.push(a);
         }
 
@@ -74,6 +77,12 @@ impl Args {
             .next()
             .ok_or_else(|| Error::Parse("missing selector".into()))?;
         let paths: Vec<Path> = iter.map(|f| Path::parse(&f)).collect::<Result<_>>()?;
+        let mut seen = HashSet::with_capacity(paths.len());
+        for p in &paths {
+            if !seen.insert(p.raw.as_str()) {
+                return Err(Error::Parse(format!("duplicate field '{}'", p.raw)));
+            }
+        }
         Ok(Self {
             selector,
             paths,

crates/blk/src/fields.rs

@@ -6,29 +6,126 @@ use bitcoin::{
 };
 use brk_error::{Error, Result};
 use brk_types::ReadBlock;
-use serde_json::{Value, json};
+use serde_json::{Map, Value, json};
 
 use crate::path::{Path, Step};
 
+// `hex` is intentionally absent: matches `bitcoin-cli getblock <hash> 2`
+// and keeps NDJSON dumps tractable. Still reachable explicitly via `blk N hex`.
+const BLOCK_FIELDS: &[&str] = &[
+    "height",
+    "hash",
+    "version",
+    "version_hex",
+    "merkle",
+    "time",
+    "nonce",
+    "bits",
+    "difficulty",
+    "prev",
+    "txs",
+    "n_inputs",
+    "n_outputs",
+    "witness_txs",
+    "size",
+    "strippedsize",
+    "weight",
+    "subsidy",
+    "coinbase",
+    "coinbase_hex",
+    "header_hex",
+    "tx",
+];
+
+const TX_FIELDS: &[&str] = &[
+    "txid",
+    "wtxid",
+    "version",
+    "locktime",
+    "size",
+    "base_size",
+    "vsize",
+    "weight",
+    "inputs",
+    "outputs",
+    "is_coinbase",
+    "has_witness",
+    "is_rbf",
+    "total_out",
+    "hex",
+    "vin",
+    "vout",
+];
+
+const VIN_FIELDS: &[&str] = &[
+    "prev_txid",
+    "prev_vout",
+    "sequence",
+    "script_sig",
+    "script_sig_asm",
+    "witness",
+    "has_witness",
+    "is_rbf",
+    "coinbase",
+];
+
+const VOUT_FIELDS: &[&str] = &[
+    "value",
+    "script_pubkey",
+    "script_pubkey_asm",
+    "type",
+    "address",
+];
+
 pub struct Ctx<'a> {
     block: &'a ReadBlock,
+    network: Network,
     size_weight: OnceCell<(usize, usize)>,
 }
 
 impl<'a> Ctx<'a> {
-    pub fn new(block: &'a ReadBlock) -> Self {
+    pub fn new(block: &'a ReadBlock, network: Network) -> Self {
         Self {
             block,
+            network,
             size_weight: OnceCell::new(),
         }
     }
 
     pub fn resolve(&self, path: &Path) -> Result<Value> {
         let (step, rest) = pop(&path.steps)?;
+        self.block_field(&step.name, step.index, rest)
+    }
+
+    pub fn resolve_str(&self, path: &Path) -> Result<String> {
+        Ok(match self.resolve(path)? {
+            Value::String(s) => s,
+            other => other.to_string(),
+        })
+    }
+
+    pub fn full(&self) -> Value {
+        let mut obj = Map::with_capacity(BLOCK_FIELDS.len());
+        for &name in BLOCK_FIELDS {
+            obj.insert(
+                name.into(),
+                self.block_field(name, None, &[]).expect("known block field"),
+            );
+        }
+        Value::Object(obj)
+    }
+
+    fn size_and_weight(&self) -> (usize, usize) {
+        *self
+            .size_weight
+            .get_or_init(|| self.block.total_size_and_weight())
+    }
+
+    fn block_field(&self, name: &str, index: Option<usize>, rest: &[Step]) -> Result<Value> {
         let b = self.block;
         let raw: &Block = b;
-        let scalar = |v| scalar_leaf(v, step, rest);
-        match step.name.as_str() {
+        let scalar = |v| scalar_leaf(v, name, index, rest);
+        match name {
             "height" => scalar(json!(*b.height())),
             "hash" => scalar(json!(b.hash().to_string())),
             "time" => scalar(json!(b.header.time)),
@@ -37,7 +134,7 @@ impl<'a> Ctx<'a> {
                 "{:08x}",
                 b.header.version.to_consensus() as u32
             ))),
-            "bits" => scalar(json!(b.header.bits.to_consensus())),
+            "bits" => scalar(json!(format!("{:08x}", b.header.bits.to_consensus()))),
             "nonce" => scalar(json!(b.header.nonce)),
             "prev" => scalar(json!(b.header.prev_blockhash.to_string())),
             "merkle" => scalar(json!(b.header.merkle_root.to_string())),
@@ -62,102 +159,154 @@ impl<'a> Ctx<'a> {
             "header_hex" => scalar(json!(serialize_hex(&b.header))),
             "hex" => scalar(json!(serialize_hex(raw))),
             "coinbase" => scalar(json!(b.coinbase_tag().as_str())),
-            "tx" => pick(&b.txdata, step, rest, |i, tx| resolve_tx(tx, i == 0, rest)),
+            "coinbase_hex" => {
+                debug_assert!(
+                    !b.txdata.is_empty() && !b.txdata[0].input.is_empty(),
+                    "consensus-valid block has a coinbase tx with at least one input"
+                );
+                scalar(json!(b.txdata[0].input[0].script_sig.to_hex_string()))
+            }
+            "tx" => pick(&b.txdata, name, index, |i, tx| {
+                self.resolve_tx(tx, i == 0, rest)
+            }),
             other => Err(unknown("block", other)),
         }
     }
 
-    pub fn resolve_str(&self, path: &Path) -> Result<String> {
-        Ok(match self.resolve(path)? {
-            Value::String(s) => s,
-            other => other.to_string(),
-        })
+    fn resolve_tx(&self, tx: &Transaction, is_coinbase: bool, steps: &[Step]) -> Result<Value> {
+        if steps.is_empty() {
+            let mut obj = Map::with_capacity(TX_FIELDS.len());
+            for &name in TX_FIELDS {
+                obj.insert(
+                    name.into(),
+                    self.tx_field(tx, is_coinbase, name, None, &[])
+                        .expect("known tx field"),
+                );
+            }
+            return Ok(Value::Object(obj));
+        }
+        let (step, rest) = pop(steps)?;
+        self.tx_field(tx, is_coinbase, &step.name, step.index, rest)
     }
 
-    pub fn full(&self) -> Value {
-        let b = self.block;
-        let (size, weight) = self.size_and_weight();
-        let tx: Vec<Value> = b
-            .txdata
-            .iter()
-            .enumerate()
-            .map(|(i, tx)| tx_to_value(tx, i == 0))
-            .collect();
-        json!({
-            "height": *b.height(),
-            "hash": b.hash().to_string(),
-            "version": b.header.version.to_consensus(),
-            "version_hex": format!("{:08x}", b.header.version.to_consensus() as u32),
-            "merkle": b.header.merkle_root.to_string(),
-            "time": b.header.time,
-            "nonce": b.header.nonce,
-            "bits": b.header.bits.to_consensus(),
-            "difficulty": b.header.difficulty_float(),
-            "prev": b.header.prev_blockhash.to_string(),
-            "txs": b.txdata.len(),
-            "n_inputs": b.txdata.iter().map(|t| t.input.len()).sum::<usize>(),
-            "n_outputs": b.txdata.iter().map(|t| t.output.len()).sum::<usize>(),
-            "witness_txs": b.txdata.iter().filter(|t| tx_has_witness(t)).count(),
-            "size": size,
-            "strippedsize": (weight - size) / 3,
-            "weight": weight,
-            "subsidy": subsidy_sats(*b.height()),
-            "coinbase": b.coinbase_tag().as_str(),
-            "header_hex": serialize_hex(&b.header),
-            "tx": tx,
-        })
+    fn tx_field(
+        &self,
+        tx: &Transaction,
+        is_coinbase: bool,
+        name: &str,
+        index: Option<usize>,
+        rest: &[Step],
+    ) -> Result<Value> {
+        let scalar = |v| scalar_leaf(v, name, index, rest);
+        match name {
+            "txid" => scalar(json!(tx.compute_txid().to_string())),
+            "wtxid" => scalar(json!(tx.compute_wtxid().to_string())),
+            "version" => scalar(json!(tx.version.0)),
+            "locktime" => scalar(json!(tx.lock_time.to_consensus_u32())),
+            "size" => scalar(json!(tx.total_size())),
+            "base_size" => scalar(json!(tx.base_size())),
+            "vsize" => scalar(json!(tx.vsize())),
+            "weight" => scalar(json!(tx.weight().to_wu())),
+            "inputs" => scalar(json!(tx.input.len())),
+            "outputs" => scalar(json!(tx.output.len())),
+            "is_coinbase" => scalar(json!(is_coinbase)),
+            "has_witness" => scalar(json!(tx_has_witness(tx))),
+            "is_rbf" => scalar(json!(tx_is_rbf(tx))),
+            "total_out" => scalar(json!(tx_total_out(tx))),
+            "hex" => scalar(json!(serialize_hex(tx))),
+            "vin" => pick(&tx.input, name, index, |j, vin| {
+                resolve_vin(vin, is_coinbase && j == 0, rest)
+            }),
+            "vout" => pick(&tx.output, name, index, |_, vout| {
+                self.resolve_vout(vout, rest)
+            }),
+            other => Err(unknown("tx", other)),
+        }
     }
 
-    fn size_and_weight(&self) -> (usize, usize) {
-        *self
-            .size_weight
-            .get_or_init(|| self.block.total_size_and_weight())
+    fn resolve_vout(&self, vout: &TxOut, steps: &[Step]) -> Result<Value> {
+        if steps.is_empty() {
+            let mut obj = Map::with_capacity(VOUT_FIELDS.len());
+            for &name in VOUT_FIELDS {
+                obj.insert(
+                    name.into(),
+                    self.vout_field(vout, name, None, &[])
+                        .expect("known vout field"),
+                );
+            }
+            return Ok(Value::Object(obj));
+        }
+        let (step, rest) = pop(steps)?;
+        self.vout_field(vout, &step.name, step.index, rest)
     }
-}
 
-fn resolve_tx(tx: &Transaction, is_coinbase: bool, steps: &[Step]) -> Result<Value> {
-    if steps.is_empty() {
-        return Ok(tx_to_value(tx, is_coinbase));
+    fn vout_field(
+        &self,
+        vout: &TxOut,
+        name: &str,
+        index: Option<usize>,
+        rest: &[Step],
+    ) -> Result<Value> {
+        let scalar = |v| scalar_leaf(v, name, index, rest);
+        match name {
+            "value" => scalar(json!(vout.value.to_sat())),
+            "script_pubkey" => scalar(json!(vout.script_pubkey.to_hex_string())),
+            "script_pubkey_asm" => scalar(json!(vout.script_pubkey.to_asm_string())),
+            "type" => scalar(json!(script_type(&vout.script_pubkey))),
+            "address" => scalar(self.address_value(&vout.script_pubkey)),
+            other => Err(unknown("vout", other)),
+        }
     }
-    let (step, rest) = pop(steps)?;
-    let scalar = |v| scalar_leaf(v, step, rest);
-    match step.name.as_str() {
-        "txid" => scalar(json!(tx.compute_txid().to_string())),
-        "wtxid" => scalar(json!(tx.compute_wtxid().to_string())),
-        "version" => scalar(json!(tx.version.0)),
-        "locktime" => scalar(json!(tx.lock_time.to_consensus_u32())),
-        "size" => scalar(json!(tx.total_size())),
-        "base_size" => scalar(json!(tx.base_size())),
-        "vsize" => scalar(json!(tx.vsize())),
-        "weight" => scalar(json!(tx.weight().to_wu())),
-        "inputs" => scalar(json!(tx.input.len())),
-        "outputs" => scalar(json!(tx.output.len())),
-        "is_coinbase" => scalar(json!(is_coinbase)),
-        "has_witness" => scalar(json!(tx_has_witness(tx))),
-        "is_rbf" => scalar(json!(tx_is_rbf(tx))),
-        "total_out" => scalar(json!(tx_total_out(tx))),
-        "hex" => scalar(json!(serialize_hex(tx))),
-        "vin" => pick(&tx.input, step, rest, |j, vin| {
-            resolve_vin(vin, is_coinbase && j == 0, rest)
-        }),
-        "vout" => pick(&tx.output, step, rest, |_, vout| resolve_vout(vout, rest)),
-        other => Err(unknown("tx", other)),
+
+    fn address_value(&self, s: &ScriptBuf) -> Value {
+        Address::from_script(s, self.network)
+            .map(|a| Value::String(a.to_string()))
+            .unwrap_or(Value::Null)
     }
 }
 
 fn resolve_vin(vin: &TxIn, is_coinbase: bool, steps: &[Step]) -> Result<Value> {
     if steps.is_empty() {
-        return Ok(vin_to_value(vin, is_coinbase));
+        let mut obj = Map::with_capacity(VIN_FIELDS.len());
+        for &name in VIN_FIELDS {
+            obj.insert(
+                name.into(),
+                vin_field(vin, is_coinbase, name, None, &[]).expect("known vin field"),
+            );
+        }
+        return Ok(Value::Object(obj));
     }
     let (step, rest) = pop(steps)?;
-    let scalar = |v| scalar_leaf(v, step, rest);
-    match step.name.as_str() {
+    vin_field(vin, is_coinbase, &step.name, step.index, rest)
+}
+
+fn vin_field(
+    vin: &TxIn,
+    is_coinbase: bool,
+    name: &str,
+    index: Option<usize>,
+    rest: &[Step],
+) -> Result<Value> {
+    let scalar = |v| scalar_leaf(v, name, index, rest);
+    match name {
         "prev_txid" => scalar(json!(vin.previous_output.txid.to_string())),
         "prev_vout" => scalar(json!(vin.previous_output.vout)),
         "sequence" => scalar(json!(vin.sequence.0)),
         "script_sig" => scalar(json!(vin.script_sig.to_hex_string())),
         "script_sig_asm" => scalar(json!(vin.script_sig.to_asm_string())),
-        "witness" => scalar(witness_to_value(vin)),
+        "witness" => {
+            if !rest.is_empty() {
+                return Err(Error::Parse(
+                    "'witness' element has no fields to drill into".into(),
+                ));
+            }
+            let items: Vec<String> = vin
+                .witness
+                .iter()
+                .map(|w| w.to_lower_hex_string())
+                .collect();
+            pick(&items, name, index, |_, hex| Ok(Value::String(hex.clone())))
+        }
         "has_witness" => scalar(json!(!vin.witness.is_empty())),
         "is_rbf" => scalar(json!(vin.sequence.is_rbf())),
         "coinbase" => scalar(json!(is_coinbase)),
@@ -165,33 +314,17 @@ fn resolve_vin(vin: &TxIn, is_coinbase: bool, steps: &[Step]) -> Result<Value> {
     }
 }
 
-fn resolve_vout(vout: &TxOut, steps: &[Step]) -> Result<Value> {
-    if steps.is_empty() {
-        return Ok(vout_to_value(vout));
-    }
-    let (step, rest) = pop(steps)?;
-    let scalar = |v| scalar_leaf(v, step, rest);
-    match step.name.as_str() {
-        "value" => scalar(json!(vout.value.to_sat())),
-        "script_pubkey" => scalar(json!(vout.script_pubkey.to_hex_string())),
-        "script_pubkey_asm" => scalar(json!(vout.script_pubkey.to_asm_string())),
-        "type" => scalar(json!(script_type(&vout.script_pubkey))),
-        "address" => scalar(address_value(&vout.script_pubkey)),
-        other => Err(unknown("vout", other)),
-    }
-}
-
 fn pick<T>(
     items: &[T],
-    step: &Step,
-    _rest: &[Step],
+    name: &str,
+    index: Option<usize>,
     mut resolve: impl FnMut(usize, &T) -> Result<Value>,
 ) -> Result<Value> {
-    match step.index {
+    match index {
         Some(i) => {
             let item = items
                 .get(i)
-                .ok_or_else(|| out_of_range(&step.name, i, items.len()))?;
+                .ok_or_else(|| out_of_range(name, i, items.len()))?;
             resolve(i, item)
         }
         None => Ok(Value::Array(
@@ -210,14 +343,13 @@ fn pop(steps: &[Step]) -> Result<(&Step, &[Step])> {
         .ok_or_else(|| Error::Parse("empty path segment".into()))
 }
 
-fn scalar_leaf(v: Value, step: &Step, rest: &[Step]) -> Result<Value> {
-    if step.index.is_some() {
-        return Err(Error::Parse(format!("'{}' is not an array", step.name)));
+fn scalar_leaf(v: Value, name: &str, index: Option<usize>, rest: &[Step]) -> Result<Value> {
+    if index.is_some() {
+        return Err(Error::Parse(format!("'{name}' is not an array")));
     }
     if !rest.is_empty() {
         return Err(Error::Parse(format!(
-            "'{}' is a scalar; nothing to drill into",
-            step.name
+            "'{name}' has no fields to drill into"
         )));
     }
     Ok(v)
@@ -233,59 +365,6 @@ fn unknown(level: &str, name: &str) -> Error {
     ))
 }
 
-fn tx_to_value(tx: &Transaction, is_coinbase: bool) -> Value {
-    let vin: Vec<Value> = tx
-        .input
-        .iter()
-        .enumerate()
-        .map(|(j, v)| vin_to_value(v, is_coinbase && j == 0))
-        .collect();
-    let vout: Vec<Value> = tx.output.iter().map(vout_to_value).collect();
-    json!({
-        "txid": tx.compute_txid().to_string(),
-        "wtxid": tx.compute_wtxid().to_string(),
-        "version": tx.version.0,
-        "locktime": tx.lock_time.to_consensus_u32(),
-        "size": tx.total_size(),
-        "base_size": tx.base_size(),
-        "vsize": tx.vsize(),
-        "weight": tx.weight().to_wu(),
-        "inputs": tx.input.len(),
-        "outputs": tx.output.len(),
-        "is_coinbase": is_coinbase,
-        "has_witness": tx_has_witness(tx),
-        "is_rbf": tx_is_rbf(tx),
-        "total_out": tx_total_out(tx),
-        "hex": serialize_hex(tx),
-        "vin": vin,
-        "vout": vout,
-    })
-}
-
-fn vin_to_value(vin: &TxIn, is_coinbase: bool) -> Value {
-    json!({
-        "prev_txid": vin.previous_output.txid.to_string(),
-        "prev_vout": vin.previous_output.vout,
-        "sequence": vin.sequence.0,
-        "script_sig": vin.script_sig.to_hex_string(),
-        "script_sig_asm": vin.script_sig.to_asm_string(),
-        "witness": witness_to_value(vin),
-        "has_witness": !vin.witness.is_empty(),
-        "is_rbf": vin.sequence.is_rbf(),
-        "coinbase": is_coinbase,
-    })
-}
-
-fn vout_to_value(vout: &TxOut) -> Value {
-    json!({
-        "value": vout.value.to_sat(),
-        "script_pubkey": vout.script_pubkey.to_hex_string(),
-        "script_pubkey_asm": vout.script_pubkey.to_asm_string(),
-        "type": script_type(&vout.script_pubkey),
-        "address": address_value(&vout.script_pubkey),
-    })
-}
-
 fn tx_has_witness(tx: &Transaction) -> bool {
     tx.input.iter().any(|i| !i.witness.is_empty())
 }
@@ -307,15 +386,6 @@ fn subsidy_sats(height: u32) -> u64 {
     }
 }
 
-fn witness_to_value(vin: &TxIn) -> Value {
-    Value::Array(
-        vin.witness
-            .iter()
-            .map(|w| Value::String(w.to_lower_hex_string()))
-            .collect(),
-    )
-}
-
 fn script_type(s: &ScriptBuf) -> &'static str {
     if s.is_p2pkh() {
         "p2pkh"
@@ -335,9 +405,3 @@ fn script_type(s: &ScriptBuf) -> &'static str {
         "unknown"
     }
 }
-
-fn address_value(s: &ScriptBuf) -> Value {
-    Address::from_script(s, Network::Bitcoin)
-        .map(|a| Value::String(a.to_string()))
-        .unwrap_or(Value::Null)
-}

crates/blk/src/formatter.rs

@@ -15,16 +15,18 @@ impl Formatter {
 
     pub fn format(&self, ctx: &Ctx) -> Result<String> {
         match self.mode {
-            Mode::Bare => self.bare(ctx),
+            Mode::Bare => self.bare(ctx, false),
             Mode::Tsv => self.tsv(ctx),
             Mode::Json => Ok(serde_json::to_string(&self.object(ctx)?)?),
+            Mode::Pretty if self.fields.len() == 1 => self.bare(ctx, true),
             Mode::Pretty => Ok(serde_json::to_string_pretty(&self.object(ctx)?)?),
         }
     }
 
-    fn bare(&self, ctx: &Ctx) -> Result<String> {
+    fn bare(&self, ctx: &Ctx, pretty: bool) -> Result<String> {
         Ok(match ctx.resolve(&self.fields[0])? {
             Value::String(s) => s,
+            other if pretty => serde_json::to_string_pretty(&other)?,
             other => other.to_string(),
         })
     }

crates/blk/src/main.rs

@@ -37,17 +37,19 @@ fn run() -> Result<()> {
 
     let client = args.rpc()?;
     let (start, end) = Selector::parse(&args.selector, &client)?;
+    let network = client.get_network()?;
 
-    let mode = Mode::pick(args.pretty, args.compact, args.paths.len());
+    let mode = Mode::pick(args.pretty, args.compact, args.paths.len())?;
     let reader = Reader::new(args.blocks_dir(), &client);
     let formatter = Formatter::new(mode, args.paths);
-    let parser_threads = std::thread::available_parallelism()
+    let parser_threads = (std::thread::available_parallelism()
         .map(|n| n.get())
         .unwrap_or(2)
-        / 2;
+        / 2)
+        .max(1);
     for block in reader.range_with(start, end, parser_threads)?.iter() {
         let block = block?;
-        let line = formatter.format(&Ctx::new(&block))?;
+        let line = formatter.format(&Ctx::new(&block, network))?;
         if !line.is_empty() {
             println!("{line}");
         }

crates/blk/src/mode.rs

@@ -1,3 +1,5 @@
+use brk_error::{Error, Result};
+
 #[derive(Clone, Copy)]
 pub enum Mode {
     Bare,
@@ -7,8 +9,18 @@ pub enum Mode {
 }
 
 impl Mode {
-    pub fn pick(pretty: bool, compact: bool, n_fields: usize) -> Self {
-        if pretty {
+    pub fn pick(pretty: bool, compact: bool, n_fields: usize) -> Result<Self> {
+        if pretty && compact {
+            return Err(Error::Parse(
+                "--pretty and --compact are mutually exclusive".into(),
+            ));
+        }
+        if compact && n_fields == 0 {
+            return Err(Error::Parse(
+                "--compact requires at least one field".into(),
+            ));
+        }
+        Ok(if pretty {
             Self::Pretty
         } else if n_fields == 0 {
             Self::Json
@@ -18,6 +30,6 @@ impl Mode {
             Self::Tsv
         } else {
             Self::Json
-        }
+        })
     }
 }

crates/blk/src/selector.rs

@@ -6,13 +6,15 @@ pub struct Selector;
 
 impl Selector {
     pub fn parse(s: &str, client: &Client) -> Result<(Height, Height)> {
-        let (start, end) = match s.split_once("..") {
-            Some((a, b)) => (Self::endpoint(a, client)?, Self::endpoint(b, client)?),
-            None => {
-                let h = Self::endpoint(s, client)?;
-                (h, h)
-            }
+        let (a, b) = s.split_once("..").unwrap_or((s, s));
+        let needs_tip = |p: &str| p == "tip" || p.starts_with("tip-");
+        let tip = if needs_tip(a) || needs_tip(b) {
+            Some(client.get_last_height()?)
+        } else {
+            None
         };
+        let start = Self::endpoint(a, tip)?;
+        let end = Self::endpoint(b, tip)?;
         if end < start {
             return Err(Error::Parse(format!(
                 "range end {end} before start {start}"
@@ -21,15 +23,15 @@ impl Selector {
         Ok((start, end))
     }
 
-    fn endpoint(s: &str, client: &Client) -> Result<Height> {
+    fn endpoint(s: &str, tip: Option<Height>) -> Result<Height> {
         if s == "tip" {
-            return client.get_last_height();
+            return Ok(tip.expect("tip pre-resolved when input contains 'tip'"));
         }
         if let Some(rest) = s.strip_prefix("tip-") {
             let n: u32 = rest
                 .parse()
                 .map_err(|_| Error::Parse(format!("bad tip offset: {s}")))?;
-            let tip = client.get_last_height()?;
+            let tip = tip.expect("tip pre-resolved when input contains 'tip'");
             return tip
                 .checked_sub(n)
                 .ok_or_else(|| Error::Parse(format!("tip-{n} underflows genesis")));

crates/blk/src/usage.rs

@@ -1,4 +1,4 @@
-use owo_colors::OwoColorize;
+use owo_colors::{OwoColorize, Stream};
 
 const SEL_W: usize = 5; // longest selector token: "tip-N"
 const LABEL_W: usize = 28; // longest label across OUTPUT/OPTIONS/EXAMPLES (= example cmd "blk 800000 tx.0.vout.0.value")
@@ -7,18 +7,18 @@ const PH_W: usize = LABEL_W - FLAG_W - 1; // placeholder column width so flag+ph
 const GAP: usize = 4;
 
 pub fn print() {
-    println!("{} - inspect a Bitcoin Core block", "blk".bold());
+    println!("{} - inspect a Bitcoin Core block", bold("blk"));
     println!();
 
     section("USAGE");
     println!(
         "    blk {} [{} ...] [OPTIONS]",
-        "<selector>".bright_black(),
-        "<field>".bright_black()
+        dim("<selector>"),
+        dim("<field>")
     );
     println!(
         "    {}",
-        "no fields = full block as JSON (analog of `bitcoin-cli getblock <hash> 2`)".bright_black()
+        dim("no fields = full block as JSON (analog of `bitcoin-cli getblock <hash> 2`)")
     );
     println!();
 
@@ -32,15 +32,15 @@ pub fn print() {
     section("FIELDS");
     println!(
         "    {}",
-        "dotted paths drill into nested data; omit an index for arrays".bright_black()
+        dim("dotted paths drill into nested data, omit an index for arrays")
     );
     println!();
     group("block");
     fields(&[
         "height, hash, time, version, version_hex, bits, nonce,",
         "prev, merkle, difficulty, txs, n_inputs, n_outputs,",
-        "witness_txs, size, strippedsize, weight, subsidy, coinbase,",
-        "header_hex, hex",
+        "witness_txs, size, strippedsize, weight, subsidy,",
+        "coinbase, coinbase_hex, header_hex, hex",
     ]);
     println!();
     group_note("tx.i", "omit i for all txs");
@@ -61,14 +61,14 @@ pub fn print() {
     println!();
     println!(
         "    {}",
-        "Naked tx / tx.i / vin / vout returns the whole sub-object as JSON.".bright_black()
+        dim("Naked tx / tx.i / vin / vout returns the whole sub-object as JSON.")
     );
     println!();
 
     section("OUTPUT");
     out("no fields", "full block JSON object, one per line (NDJSON)");
     out("1 field", "bare value, one per line");
-    out("2+ fields", "compact JSON object, one per line (NDJSON)");
+    out("2+ fields", "JSON object, one per line (NDJSON)");
     out("-p, --pretty", "pretty JSON object instead");
     out(
         "-c, --compact",
@@ -115,18 +115,18 @@ pub fn print() {
 }
 
 fn section(name: &str) {
-    println!("{}", format!("{name}:").bold());
+    println!("{}", bold(&format!("{name}:")));
 }
 
 fn group(name: &str) {
-    println!("  {}", format!("{name}:").bold());
+    println!("  {}", bold(&format!("{name}:")));
 }
 
 fn group_note(name: &str, note: &str) {
     println!(
         "  {}  {}",
-        format!("{name}:").bold(),
-        format!("({note})").bright_black()
+        bold(&format!("{name}:")),
+        dim(&format!("({note})"))
     );
 }
 
@@ -143,7 +143,7 @@ fn pad(s: &str, width: usize) -> String {
 fn sel(token: &str, desc: &str) {
     println!(
         "    {}{}{}{desc}",
-        token.bright_black(),
+        dim(token),
         pad(token, SEL_W),
         " ".repeat(GAP),
     );
@@ -161,12 +161,12 @@ fn opt(flag: &str, ph: &str, desc: &str, default: Option<&str>) {
     let head = format!(
         "    {flag}{} {}{}{}",
         pad(flag, FLAG_W),
-        ph.bright_black(),
+        dim(ph),
         pad(ph, PH_W),
         " ".repeat(GAP),
     );
     match default {
-        Some(d) => println!("{head}{desc} {}", d.bright_black()),
+        Some(d) => println!("{head}{desc} {}", dim(d)),
         None => println!("{head}{desc}"),
     }
 }
@@ -176,6 +176,15 @@ fn ex(cmd: &str, note: &str) {
         "    {cmd}{}{}{}",
         pad(cmd, LABEL_W),
         " ".repeat(GAP),
-        format!("# {note}").bright_black()
+        dim(&format!("# {note}"))
     );
 }
+
+fn bold(s: &str) -> String {
+    s.if_supports_color(Stream::Stdout, |t| t.bold()).to_string()
+}
+
+fn dim(s: &str) -> String {
+    s.if_supports_color(Stream::Stdout, |t| t.bright_black())
+        .to_string()
+}

crates/brk_alloc/Cargo.toml

@@ -8,5 +8,5 @@ homepage.workspace = true
 repository.workspace = true
 
 [dependencies]
-libmimalloc-sys = { version = "0.1.47", features = ["extended"] }
-mimalloc = { version = "0.1.50" }
+libmimalloc-sys = { version = "0.1.49", features = ["extended"] }
+mimalloc = { version = "0.1.52" }

crates/brk_bindgen/src/generate/constants.rs

@@ -6,9 +6,9 @@
 use std::collections::BTreeMap;
 
 use brk_cohort::{
-    AGE_RANGE_NAMES, AMOUNT_RANGE_NAMES, CLASS_NAMES, EPOCH_NAMES, LOSS_NAMES, OVER_AGE_NAMES,
-    OVER_AMOUNT_NAMES, PROFIT_NAMES, PROFITABILITY_RANGE_NAMES, SPENDABLE_TYPE_NAMES, TERM_NAMES,
-    UNDER_AGE_NAMES, UNDER_AMOUNT_NAMES,
+    AGE_RANGE_NAMES, AMOUNT_RANGE_NAMES, CLASS_NAMES, ENTRY_NAMES, EPOCH_NAMES, LOSS_NAMES,
+    OVER_AGE_NAMES, OVER_AMOUNT_NAMES, PROFIT_NAMES, PROFITABILITY_RANGE_NAMES,
+    SPENDABLE_TYPE_NAMES, TERM_NAMES, UNDER_AGE_NAMES, UNDER_AMOUNT_NAMES,
 };
 use brk_types::{Index, pools};
 use serde::Serialize;
@@ -59,6 +59,7 @@ impl CohortConstants {
             ("TERM_NAMES", to_value(&TERM_NAMES)),
             ("EPOCH_NAMES", to_value(&EPOCH_NAMES)),
             ("CLASS_NAMES", to_value(&CLASS_NAMES)),
+            ("ENTRY_NAMES", to_value(&ENTRY_NAMES)),
             ("SPENDABLE_TYPE_NAMES", to_value(&SPENDABLE_TYPE_NAMES)),
             ("AGE_RANGE_NAMES", to_value(&AGE_RANGE_NAMES)),
             ("UNDER_AGE_NAMES", to_value(&UNDER_AGE_NAMES)),

crates/brk_bindgen/src/generators/javascript/api.rs

@@ -51,7 +51,7 @@ fn generate_get_method(output: &mut String, endpoint: &Endpoint) {
     }
     writeln!(
         output,
-        "   * @param {{{{ signal?: AbortSignal, onValue?: (value: {}) => void }}}} [options]",
+        "   * @param {{{{ signal?: AbortSignal, onValue?: (value: {}) => void, cache?: boolean }}}} [options]",
         return_type
     )
     .unwrap();
@@ -60,22 +60,22 @@ fn generate_get_method(output: &mut String, endpoint: &Endpoint) {
 
     let params = build_method_params(endpoint);
     let params_with_opts = if params.is_empty() {
-        "{ signal, onValue } = {}".to_string()
+        "{ signal, onValue, cache } = {}".to_string()
     } else {
-        format!("{}, {{ signal, onValue }} = {{}}", params)
+        format!("{}, {{ signal, onValue, cache }} = {{}}", params)
     };
     writeln!(output, "  async {}({}) {{", method_name, params_with_opts).unwrap();
 
     let path = build_path_template(&endpoint.path, &endpoint.path_params);
 
     let fetch_call: String = if endpoint.returns_binary() {
-        "this.getBytes(path, { signal, onValue })".to_string()
+        "this.getBytes(path, { signal, onValue, cache })".to_string()
     } else if endpoint.returns_json() {
-        "this.getJson(path, { signal, onValue })".to_string()
+        "this.getJson(path, { signal, onValue, cache })".to_string()
     } else if endpoint.response_kind.text_is_numeric() {
-        "Number(await this.getText(path, { signal, onValue: onValue ? (v) => onValue(Number(v)) : undefined }))".to_string()
+        "Number(await this.getText(path, { signal, cache, onValue: onValue ? (v) => onValue(Number(v)) : undefined }))".to_string()
     } else {
-        "this.getText(path, { signal, onValue })".to_string()
+        "this.getText(path, { signal, onValue, cache })".to_string()
     };
 
     write_path_assignment(output, endpoint, &path);
@@ -83,7 +83,7 @@ fn generate_get_method(output: &mut String, endpoint: &Endpoint) {
     if endpoint.supports_csv {
         writeln!(
             output,
-            "    if (format === 'csv') return this.getText(path, {{ signal, onValue }});"
+            "    if (format === 'csv') return this.getText(path, {{ signal, onValue, cache }});"
         )
         .unwrap();
     }

crates/brk_bindgen/src/generators/javascript/client.rs

@@ -51,6 +51,12 @@ const _openBrowserCache = (option) => {{
   return caches.open(name).catch(() => null);
 }};
 
+/**
+ * @param {{string}} url
+ * @returns {{URL}}
+ */
+const _parseBaseUrl = (url) => new URL(url, typeof location === 'undefined' ? undefined : location.href);
+
 /**
  * Custom error class for BRK client errors
  */
@@ -403,6 +409,9 @@ class BrkClientBase {{
     const isString = typeof options === 'string';
     const rawUrl = isString ? options : options.baseUrl;
     this.baseUrl = rawUrl.endsWith('/') ? rawUrl.slice(0, -1) : rawUrl;
+    const url = _parseBaseUrl(this.baseUrl);
+    this.url = url.href.endsWith('/') ? url.href.slice(0, -1) : url.href;
+    this.domain = url.hostname;
     this.timeout = isString ? 5000 : (options.timeout ?? 5000);
     /** @type {{Promise<Cache | null>}} */
     this._browserCachePromise = _openBrowserCache(isString ? undefined : options.browserCache);
@@ -448,14 +457,17 @@ class BrkClientBase {{
 
   /**
    * @param {{string}} path
-   * @param {{{{ signal?: AbortSignal }}}} [options]
+   * @param {{{{ signal?: AbortSignal, cache?: boolean }}}} [options]
    * @returns {{Promise<Response>}}
    */
-  async get(path, {{ signal }} = {{}}) {{
+  async get(path, {{ signal, cache = true }} = {{}}) {{
     const url = `${{this.baseUrl}}${{path}}`;
     const signals = [AbortSignal.timeout(this.timeout)];
     if (signal) signals.push(signal);
-    const res = await fetch(url, {{ signal: AbortSignal.any(signals) }});
+    /** @type {{RequestInit}} */
+    const init = {{ signal: AbortSignal.any(signals) }};
+    if (!cache) init.cache = 'no-store';
+    const res = await fetch(url, init);
     if (!res.ok) throw new BrkError(`HTTP ${{res.status}}: ${{url}}`, res.status);
     return res;
   }}
@@ -475,14 +487,21 @@ class BrkClientBase {{
    * @template T
    * @param {{string}} path
    * @param {{(res: Response) => Promise<T>}} parse - Response body reader
-   * @param {{{{ onValue?: (value: T) => void, signal?: AbortSignal }}}} [options]
+   * @param {{{{ onValue?: (value: T) => void, signal?: AbortSignal, cache?: boolean }}}} [options]
    * @returns {{Promise<T>}}
    */
-  async _getCached(path, parse, {{ onValue, signal }} = {{}}) {{
+  async _getCached(path, parse, {{ onValue, signal, cache = true }} = {{}}) {{
+    if (!cache) {{
+      const res = await this.get(path, {{ signal, cache }});
+      const value = await parse(res);
+      if (onValue) onValue(value);
+      return value;
+    }}
+
     const url = `${{this.baseUrl}}${{path}}`;
     /** @type {{_MemEntry<T> | undefined}} */
     const memHit = this._memGet(url);
-    const browserCache = this._browserCache ?? await this._browserCachePromise;
+    const browserCache = this._browserCache;
 
     // L1 fast path: deliver from memCache, revalidate via network.
     // ETag match → zero parse, zero clone, zero cache write, no second onValue fire.
@@ -497,8 +516,8 @@ class BrkClientBase {{
         this._memSet(url, netEtag, value);
         if (onValue) onValue(value);
         if (cloned && browserCache) {{
-          const cache = browserCache;
-          _runIdle(() => cache.put(url, cloned));
+          const cacheStore = browserCache;
+          _runIdle(() => cacheStore.put(url, cloned));
         }}
         return value;
       }} catch {{
@@ -531,8 +550,8 @@ class BrkClientBase {{
       this._memSet(url, netEtag, value);
       if (onValue) onValue(value);
       if (cloned && browserCache) {{
-        const cache = browserCache;
-        _runIdle(() => cache.put(url, cloned));
+        const cacheStore = browserCache;
+        _runIdle(() => cacheStore.put(url, cloned));
       }}
       return value;
     }} catch (e) {{
@@ -546,7 +565,7 @@ class BrkClientBase {{
    * Make a GET request expecting a JSON response. Cached and supports `onValue`.
    * @template T
    * @param {{string}} path
-   * @param {{{{ onValue?: (value: T) => void, signal?: AbortSignal }}}} [options]
+   * @param {{{{ onValue?: (value: T) => void, signal?: AbortSignal, cache?: boolean }}}} [options]
    * @returns {{Promise<T>}}
    */
   getJson(path, options) {{
@@ -557,7 +576,7 @@ class BrkClientBase {{
    * Make a GET request expecting a text response (text/plain, text/csv, ...).
    * Cached and supports `onValue`, same as `getJson`.
    * @param {{string}} path
-   * @param {{{{ onValue?: (value: string) => void, signal?: AbortSignal }}}} [options]
+   * @param {{{{ onValue?: (value: string) => void, signal?: AbortSignal, cache?: boolean }}}} [options]
    * @returns {{Promise<string>}}
    */
   getText(path, options) {{
@@ -568,7 +587,7 @@ class BrkClientBase {{
    * Make a GET request expecting binary data (application/octet-stream).
    * Cached and supports `onValue`, same as `getJson`.
    * @param {{string}} path
-   * @param {{{{ onValue?: (value: Uint8Array) => void, signal?: AbortSignal }}}} [options]
+   * @param {{{{ onValue?: (value: Uint8Array) => void, signal?: AbortSignal, cache?: boolean }}}} [options]
    * @returns {{Promise<Uint8Array>}}
    */
   getBytes(path, options) {{

crates/brk_cli/Cargo.toml

@@ -31,6 +31,3 @@ vecdb = { workspace = true }
 [[bin]]
 name = "brk"
 path = "src/main.rs"
-
-[package.metadata.dist]
-dist = true

crates/brk_cli/README.md

@@ -30,6 +30,10 @@ Portable build (without native CPU optimizations):
 cargo install --locked brk_cli
 ```
 
+## Update
+
+Updating is the same as installing: re-run the install command above. `cargo install` overwrites the existing binary in place. Indexed data is reused when the on-disk format is unchanged, otherwise it is reset and re-synced automatically on the next run.
+
 ## Run
 
 ```bash

crates/brk_client/examples/basic.rs

@@ -17,7 +17,7 @@ fn main() -> brk_client::Result<()> {
     // day1() returns DateMetricEndpointBuilder, so fetch() returns DateMetricData
     let price_close = client
         .series()
-        .prices
+        .price
         .split
         .close
         .usd

crates/brk_client/src/lib.rs

@@ -1191,6 +1191,22 @@ pub struct CapCapitalizedGrossLossMvrvNetPeakPriceProfitSellSoprPattern {
     pub sopr: AdjustedRatioValuePattern,
 }
 
+/// Pattern struct for repeated tree structure.
+pub struct CapCapitalizedGrossLossMvrvNetPeakPriceProfitSellSoprPattern2 {
+    pub cap: CentsDeltaToUsdPattern,
+    pub capitalized: PricePattern,
+    pub gross_pnl: BlockCumulativeSumPattern,
+    pub loss: BlockCumulativeNegativeSumPattern,
+    pub mvrv: SeriesPattern1<StoredF32>,
+    pub net_pnl: BlockChangeCumulativeDeltaSumPattern,
+    pub peak_regret: BlockCumulativeSumPattern,
+    pub price: BpsCentsPercentilesRatioSatsSmaStdUsdPattern,
+    pub profit: BlockCumulativeSumPattern,
+    pub profit_to_loss_ratio: _1m1w1y24hPattern<StoredF64>,
+    pub sell_side_risk_ratio: _1m1w1y24hPattern8,
+    pub sopr: RatioValuePattern2,
+}
+
 /// Pattern struct for repeated tree structure.
 pub struct EmptyOpP2aP2msP2pk33P2pk65P2pkhP2shP2trP2wpkhP2wshUnknownPattern2 {
     pub empty: _1m1w1y24hBpsPercentRatioPattern,
@@ -1658,6 +1674,17 @@ pub struct ActiveInputOutputSpendablePattern {
     pub spendable_output_to_reused_addr_share: _1m1w1y24hBpsPercentRatioPattern,
 }
 
+/// Pattern struct for repeated tree structure.
+pub struct ActivityCostInvestedOutputsRealizedSupplyUnrealizedPattern2 {
+    pub activity: CoindaysCoinyearsDormancyTransferPattern,
+    pub cost_basis: InMaxMinPerSupplyPattern,
+    pub invested_capital: InPattern,
+    pub outputs: SpendingSpentUnspentPattern,
+    pub realized: CapCapitalizedGrossLossMvrvNetPeakPriceProfitSellSoprPattern2,
+    pub supply: DeltaDominanceHalfInTotalPattern2,
+    pub unrealized: CapitalizedGrossInvestedLossNetNuplProfitSentimentPattern2,
+}
+
 /// Pattern struct for repeated tree structure.
 pub struct CapLossMvrvNetPriceProfitSoprPattern {
     pub cap: CentsDeltaUsdPattern,
@@ -3408,6 +3435,22 @@ impl PriceRatioPattern {
     }
 }
 
+/// Pattern struct for repeated tree structure.
+pub struct RatioValuePattern2 {
+    pub ratio: _1m1w1y24hPattern<StoredF64>,
+    pub value_destroyed: AverageBlockCumulativeSumPattern<Cents>,
+}
+
+impl RatioValuePattern2 {
+    /// Create a new pattern node with accumulated series name.
+    pub fn new(client: Arc<BrkClientBase>, acc: String) -> Self {
+        Self {
+            ratio: _1m1w1y24hPattern::new(client.clone(), _m(&acc, "sopr")),
+            value_destroyed: AverageBlockCumulativeSumPattern::new(client.clone(), _m(&acc, "value_destroyed")),
+        }
+    }
+}
+
 /// Pattern struct for repeated tree structure.
 pub struct RatioValuePattern {
     pub ratio: _24hPattern,
@@ -3534,7 +3577,7 @@ pub struct SeriesTree {
     pub investing: SeriesTree_Investing,
     pub market: SeriesTree_Market,
     pub pools: SeriesTree_Pools,
-    pub prices: SeriesTree_Prices,
+    pub price: SeriesTree_Price,
     pub supply: SeriesTree_Supply,
     pub cohorts: SeriesTree_Cohorts,
 }
@@ -3556,7 +3599,7 @@ impl SeriesTree {
             investing: SeriesTree_Investing::new(client.clone(), format!("{base_path}_investing")),
             market: SeriesTree_Market::new(client.clone(), format!("{base_path}_market")),
             pools: SeriesTree_Pools::new(client.clone(), format!("{base_path}_pools")),
-            prices: SeriesTree_Prices::new(client.clone(), format!("{base_path}_prices")),
+            price: SeriesTree_Price::new(client.clone(), format!("{base_path}_price")),
             supply: SeriesTree_Supply::new(client.clone(), format!("{base_path}_supply")),
             cohorts: SeriesTree_Cohorts::new(client.clone(), format!("{base_path}_cohorts")),
         }
@@ -7063,31 +7106,31 @@ impl SeriesTree_Pools_Minor {
 }
 
 /// Series tree node.
-pub struct SeriesTree_Prices {
-    pub split: SeriesTree_Prices_Split,
-    pub ohlc: SeriesTree_Prices_Ohlc,
-    pub spot: SeriesTree_Prices_Spot,
+pub struct SeriesTree_Price {
+    pub split: SeriesTree_Price_Split,
+    pub ohlc: SeriesTree_Price_Ohlc,
+    pub spot: SeriesTree_Price_Spot,
 }
 
-impl SeriesTree_Prices {
+impl SeriesTree_Price {
     pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
         Self {
-            split: SeriesTree_Prices_Split::new(client.clone(), format!("{base_path}_split")),
-            ohlc: SeriesTree_Prices_Ohlc::new(client.clone(), format!("{base_path}_ohlc")),
-            spot: SeriesTree_Prices_Spot::new(client.clone(), format!("{base_path}_spot")),
+            split: SeriesTree_Price_Split::new(client.clone(), format!("{base_path}_split")),
+            ohlc: SeriesTree_Price_Ohlc::new(client.clone(), format!("{base_path}_ohlc")),
+            spot: SeriesTree_Price_Spot::new(client.clone(), format!("{base_path}_spot")),
         }
     }
 }
 
 /// Series tree node.
-pub struct SeriesTree_Prices_Split {
+pub struct SeriesTree_Price_Split {
     pub open: CentsSatsUsdPattern3,
     pub high: CentsSatsUsdPattern3,
     pub low: CentsSatsUsdPattern3,
     pub close: CentsSatsUsdPattern3,
 }
 
-impl SeriesTree_Prices_Split {
+impl SeriesTree_Price_Split {
     pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
         Self {
             open: CentsSatsUsdPattern3::new(client.clone(), "price_open".to_string()),
@@ -7099,13 +7142,13 @@ impl SeriesTree_Prices_Split {
 }
 
 /// Series tree node.
-pub struct SeriesTree_Prices_Ohlc {
+pub struct SeriesTree_Price_Ohlc {
     pub usd: SeriesPattern2<OHLCDollars>,
     pub cents: SeriesPattern2<OHLCCents>,
     pub sats: SeriesPattern2<OHLCSats>,
 }
 
-impl SeriesTree_Prices_Ohlc {
+impl SeriesTree_Price_Ohlc {
     pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
         Self {
             usd: SeriesPattern2::new(client.clone(), "price_ohlc".to_string()),
@@ -7116,13 +7159,13 @@ impl SeriesTree_Prices_Ohlc {
 }
 
 /// Series tree node.
-pub struct SeriesTree_Prices_Spot {
+pub struct SeriesTree_Price_Spot {
     pub usd: SeriesPattern1<Dollars>,
     pub cents: SeriesPattern1<Cents>,
     pub sats: SeriesPattern1<Sats>,
 }
 
-impl SeriesTree_Prices_Spot {
+impl SeriesTree_Price_Spot {
     pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
         Self {
             usd: SeriesPattern1::new(client.clone(), "price".to_string()),
@@ -7199,6 +7242,7 @@ pub struct SeriesTree_Cohorts_Utxo {
     pub over_age: SeriesTree_Cohorts_Utxo_OverAge,
     pub epoch: SeriesTree_Cohorts_Utxo_Epoch,
     pub class: SeriesTree_Cohorts_Utxo_Class,
+    pub entry: SeriesTree_Cohorts_Utxo_Entry,
     pub over_amount: SeriesTree_Cohorts_Utxo_OverAmount,
     pub amount_range: SeriesTree_Cohorts_Utxo_AmountRange,
     pub under_amount: SeriesTree_Cohorts_Utxo_UnderAmount,
@@ -7218,6 +7262,7 @@ impl SeriesTree_Cohorts_Utxo {
             over_age: SeriesTree_Cohorts_Utxo_OverAge::new(client.clone(), format!("{base_path}_over_age")),
             epoch: SeriesTree_Cohorts_Utxo_Epoch::new(client.clone(), format!("{base_path}_epoch")),
             class: SeriesTree_Cohorts_Utxo_Class::new(client.clone(), format!("{base_path}_class")),
+            entry: SeriesTree_Cohorts_Utxo_Entry::new(client.clone(), format!("{base_path}_entry")),
             over_amount: SeriesTree_Cohorts_Utxo_OverAmount::new(client.clone(), format!("{base_path}_over_amount")),
             amount_range: SeriesTree_Cohorts_Utxo_AmountRange::new(client.clone(), format!("{base_path}_amount_range")),
             under_amount: SeriesTree_Cohorts_Utxo_UnderAmount::new(client.clone(), format!("{base_path}_under_amount")),
@@ -7999,7 +8044,7 @@ pub struct SeriesTree_Cohorts_Utxo_Lth_Realized {
     pub price: SeriesTree_Cohorts_Utxo_Lth_Realized_Price,
     pub mvrv: SeriesPattern1<StoredF32>,
     pub net_pnl: BlockChangeCumulativeDeltaSumPattern,
-    pub sopr: SeriesTree_Cohorts_Utxo_Lth_Realized_Sopr,
+    pub sopr: RatioValuePattern2,
     pub gross_pnl: BlockCumulativeSumPattern,
     pub sell_side_risk_ratio: _1m1w1y24hPattern8,
     pub peak_regret: BlockCumulativeSumPattern,
@@ -8016,7 +8061,7 @@ impl SeriesTree_Cohorts_Utxo_Lth_Realized {
             price: SeriesTree_Cohorts_Utxo_Lth_Realized_Price::new(client.clone(), format!("{base_path}_price")),
             mvrv: SeriesPattern1::new(client.clone(), "lth_mvrv".to_string()),
             net_pnl: BlockChangeCumulativeDeltaSumPattern::new(client.clone(), "lth_net".to_string()),
-            sopr: SeriesTree_Cohorts_Utxo_Lth_Realized_Sopr::new(client.clone(), format!("{base_path}_sopr")),
+            sopr: RatioValuePattern2::new(client.clone(), "lth".to_string()),
             gross_pnl: BlockCumulativeSumPattern::new(client.clone(), "lth_realized_gross_pnl".to_string()),
             sell_side_risk_ratio: _1m1w1y24hPattern8::new(client.clone(), "lth_sell_side_risk_ratio".to_string()),
             peak_regret: BlockCumulativeSumPattern::new(client.clone(), "lth_realized_peak_regret".to_string()),
@@ -8236,21 +8281,6 @@ impl SeriesTree_Cohorts_Utxo_Lth_Realized_Price_StdDev_1y {
     }
 }
 
-/// Series tree node.
-pub struct SeriesTree_Cohorts_Utxo_Lth_Realized_Sopr {
-    pub value_destroyed: AverageBlockCumulativeSumPattern<Cents>,
-    pub ratio: _1m1w1y24hPattern<StoredF64>,
-}
-
-impl SeriesTree_Cohorts_Utxo_Lth_Realized_Sopr {
-    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
-        Self {
-            value_destroyed: AverageBlockCumulativeSumPattern::new(client.clone(), "lth_value_destroyed".to_string()),
-            ratio: _1m1w1y24hPattern::new(client.clone(), "lth_sopr".to_string()),
-        }
-    }
-}
-
 /// Series tree node.
 pub struct SeriesTree_Cohorts_Utxo_AgeRange {
     pub under_1h: ActivityOutputsRealizedSupplyUnrealizedPattern,
@@ -8466,6 +8496,561 @@ impl SeriesTree_Cohorts_Utxo_Class {
     }
 }
 
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry {
+    pub discount: SeriesTree_Cohorts_Utxo_Entry_Discount,
+    pub premium: SeriesTree_Cohorts_Utxo_Entry_Premium,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            discount: SeriesTree_Cohorts_Utxo_Entry_Discount::new(client.clone(), format!("{base_path}_discount")),
+            premium: SeriesTree_Cohorts_Utxo_Entry_Premium::new(client.clone(), format!("{base_path}_premium")),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount {
+    pub supply: DeltaDominanceHalfInTotalPattern2,
+    pub outputs: SpendingSpentUnspentPattern,
+    pub activity: CoindaysCoinyearsDormancyTransferPattern,
+    pub realized: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized,
+    pub cost_basis: InMaxMinPerSupplyPattern,
+    pub unrealized: CapitalizedGrossInvestedLossNetNuplProfitSentimentPattern2,
+    pub invested_capital: InPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            supply: DeltaDominanceHalfInTotalPattern2::new(client.clone(), "veteran_supply".to_string()),
+            outputs: SpendingSpentUnspentPattern::new(client.clone(), "veteran".to_string()),
+            activity: CoindaysCoinyearsDormancyTransferPattern::new(client.clone(), "veteran".to_string()),
+            realized: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized::new(client.clone(), format!("{base_path}_realized")),
+            cost_basis: InMaxMinPerSupplyPattern::new(client.clone(), "veteran".to_string()),
+            unrealized: CapitalizedGrossInvestedLossNetNuplProfitSentimentPattern2::new(client.clone(), "veteran".to_string()),
+            invested_capital: InPattern::new(client.clone(), "veteran_invested_capital_in".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount_Realized {
+    pub cap: CentsDeltaToUsdPattern,
+    pub profit: BlockCumulativeSumPattern,
+    pub loss: BlockCumulativeNegativeSumPattern,
+    pub price: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price,
+    pub mvrv: SeriesPattern1<StoredF32>,
+    pub net_pnl: BlockChangeCumulativeDeltaSumPattern,
+    pub sopr: RatioValuePattern2,
+    pub gross_pnl: BlockCumulativeSumPattern,
+    pub sell_side_risk_ratio: _1m1w1y24hPattern8,
+    pub peak_regret: BlockCumulativeSumPattern,
+    pub capitalized: PricePattern,
+    pub profit_to_loss_ratio: _1m1w1y24hPattern<StoredF64>,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount_Realized {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            cap: CentsDeltaToUsdPattern::new(client.clone(), "veteran_realized_cap".to_string()),
+            profit: BlockCumulativeSumPattern::new(client.clone(), "veteran_realized_profit".to_string()),
+            loss: BlockCumulativeNegativeSumPattern::new(client.clone(), "veteran_realized_loss".to_string()),
+            price: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price::new(client.clone(), format!("{base_path}_price")),
+            mvrv: SeriesPattern1::new(client.clone(), "veteran_mvrv".to_string()),
+            net_pnl: BlockChangeCumulativeDeltaSumPattern::new(client.clone(), "veteran_net".to_string()),
+            sopr: RatioValuePattern2::new(client.clone(), "veteran".to_string()),
+            gross_pnl: BlockCumulativeSumPattern::new(client.clone(), "veteran_realized_gross_pnl".to_string()),
+            sell_side_risk_ratio: _1m1w1y24hPattern8::new(client.clone(), "veteran_sell_side_risk_ratio".to_string()),
+            peak_regret: BlockCumulativeSumPattern::new(client.clone(), "veteran_realized_peak_regret".to_string()),
+            capitalized: PricePattern::new(client.clone(), "veteran_capitalized_price".to_string()),
+            profit_to_loss_ratio: _1m1w1y24hPattern::new(client.clone(), "veteran_realized_profit_to_loss_ratio".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price {
+    pub usd: SeriesPattern1<Dollars>,
+    pub cents: SeriesPattern1<Cents>,
+    pub sats: SeriesPattern1<SatsFract>,
+    pub bps: SeriesPattern1<BasisPoints32>,
+    pub ratio: SeriesPattern1<StoredF32>,
+    pub percentiles: Pct0Pct1Pct2Pct5Pct95Pct98Pct99Pattern,
+    pub sma: _1m1w1y2y4yAllPattern,
+    pub std_dev: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            usd: SeriesPattern1::new(client.clone(), "veteran_realized_price".to_string()),
+            cents: SeriesPattern1::new(client.clone(), "veteran_realized_price_cents".to_string()),
+            sats: SeriesPattern1::new(client.clone(), "veteran_realized_price_sats".to_string()),
+            bps: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_bps".to_string()),
+            ratio: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio".to_string()),
+            percentiles: Pct0Pct1Pct2Pct5Pct95Pct98Pct99Pattern::new(client.clone(), "veteran_realized_price".to_string()),
+            sma: _1m1w1y2y4yAllPattern::new(client.clone(), "veteran_realized_price_ratio_sma".to_string()),
+            std_dev: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev::new(client.clone(), format!("{base_path}_std_dev")),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev {
+    pub all: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_All,
+    pub _4y: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_4y,
+    pub _2y: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_2y,
+    pub _1y: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_1y,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            all: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_All::new(client.clone(), format!("{base_path}_all")),
+            _4y: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_4y::new(client.clone(), format!("{base_path}_4y")),
+            _2y: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_2y::new(client.clone(), format!("{base_path}_2y")),
+            _1y: SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_1y::new(client.clone(), format!("{base_path}_1y")),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_All {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_All {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_sd".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_zscore".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "veteran_realized_price_0sd".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p0_5sd".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1sd".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1_5sd".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2sd".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2_5sd".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p3sd".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m0_5sd".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1sd".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1_5sd".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2sd".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2_5sd".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m3sd".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_4y {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_4y {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_sd_4y".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_zscore_4y".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "veteran_realized_price_0sd_4y".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p0_5sd_4y".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1sd_4y".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1_5sd_4y".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2sd_4y".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2_5sd_4y".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p3sd_4y".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m0_5sd_4y".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1sd_4y".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1_5sd_4y".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2sd_4y".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2_5sd_4y".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m3sd_4y".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_2y {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_2y {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_sd_2y".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_zscore_2y".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "veteran_realized_price_0sd_2y".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p0_5sd_2y".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1sd_2y".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1_5sd_2y".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2sd_2y".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2_5sd_2y".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p3sd_2y".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m0_5sd_2y".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1sd_2y".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1_5sd_2y".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2sd_2y".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2_5sd_2y".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m3sd_2y".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_1y {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Discount_Realized_Price_StdDev_1y {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_sd_1y".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "veteran_realized_price_ratio_zscore_1y".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "veteran_realized_price_0sd_1y".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p0_5sd_1y".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1sd_1y".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p1_5sd_1y".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2sd_1y".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p2_5sd_1y".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "p3sd_1y".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m0_5sd_1y".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1sd_1y".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m1_5sd_1y".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2sd_1y".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m2_5sd_1y".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "veteran_realized_price".to_string(), "m3sd_1y".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium {
+    pub supply: DeltaDominanceHalfInTotalPattern2,
+    pub outputs: SpendingSpentUnspentPattern,
+    pub activity: CoindaysCoinyearsDormancyTransferPattern,
+    pub realized: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized,
+    pub cost_basis: InMaxMinPerSupplyPattern,
+    pub unrealized: CapitalizedGrossInvestedLossNetNuplProfitSentimentPattern2,
+    pub invested_capital: InPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            supply: DeltaDominanceHalfInTotalPattern2::new(client.clone(), "rookie_supply".to_string()),
+            outputs: SpendingSpentUnspentPattern::new(client.clone(), "rookie".to_string()),
+            activity: CoindaysCoinyearsDormancyTransferPattern::new(client.clone(), "rookie".to_string()),
+            realized: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized::new(client.clone(), format!("{base_path}_realized")),
+            cost_basis: InMaxMinPerSupplyPattern::new(client.clone(), "rookie".to_string()),
+            unrealized: CapitalizedGrossInvestedLossNetNuplProfitSentimentPattern2::new(client.clone(), "rookie".to_string()),
+            invested_capital: InPattern::new(client.clone(), "rookie_invested_capital_in".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium_Realized {
+    pub cap: CentsDeltaToUsdPattern,
+    pub profit: BlockCumulativeSumPattern,
+    pub loss: BlockCumulativeNegativeSumPattern,
+    pub price: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price,
+    pub mvrv: SeriesPattern1<StoredF32>,
+    pub net_pnl: BlockChangeCumulativeDeltaSumPattern,
+    pub sopr: RatioValuePattern2,
+    pub gross_pnl: BlockCumulativeSumPattern,
+    pub sell_side_risk_ratio: _1m1w1y24hPattern8,
+    pub peak_regret: BlockCumulativeSumPattern,
+    pub capitalized: PricePattern,
+    pub profit_to_loss_ratio: _1m1w1y24hPattern<StoredF64>,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium_Realized {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            cap: CentsDeltaToUsdPattern::new(client.clone(), "rookie_realized_cap".to_string()),
+            profit: BlockCumulativeSumPattern::new(client.clone(), "rookie_realized_profit".to_string()),
+            loss: BlockCumulativeNegativeSumPattern::new(client.clone(), "rookie_realized_loss".to_string()),
+            price: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price::new(client.clone(), format!("{base_path}_price")),
+            mvrv: SeriesPattern1::new(client.clone(), "rookie_mvrv".to_string()),
+            net_pnl: BlockChangeCumulativeDeltaSumPattern::new(client.clone(), "rookie_net".to_string()),
+            sopr: RatioValuePattern2::new(client.clone(), "rookie".to_string()),
+            gross_pnl: BlockCumulativeSumPattern::new(client.clone(), "rookie_realized_gross_pnl".to_string()),
+            sell_side_risk_ratio: _1m1w1y24hPattern8::new(client.clone(), "rookie_sell_side_risk_ratio".to_string()),
+            peak_regret: BlockCumulativeSumPattern::new(client.clone(), "rookie_realized_peak_regret".to_string()),
+            capitalized: PricePattern::new(client.clone(), "rookie_capitalized_price".to_string()),
+            profit_to_loss_ratio: _1m1w1y24hPattern::new(client.clone(), "rookie_realized_profit_to_loss_ratio".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price {
+    pub usd: SeriesPattern1<Dollars>,
+    pub cents: SeriesPattern1<Cents>,
+    pub sats: SeriesPattern1<SatsFract>,
+    pub bps: SeriesPattern1<BasisPoints32>,
+    pub ratio: SeriesPattern1<StoredF32>,
+    pub percentiles: Pct0Pct1Pct2Pct5Pct95Pct98Pct99Pattern,
+    pub sma: _1m1w1y2y4yAllPattern,
+    pub std_dev: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            usd: SeriesPattern1::new(client.clone(), "rookie_realized_price".to_string()),
+            cents: SeriesPattern1::new(client.clone(), "rookie_realized_price_cents".to_string()),
+            sats: SeriesPattern1::new(client.clone(), "rookie_realized_price_sats".to_string()),
+            bps: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_bps".to_string()),
+            ratio: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio".to_string()),
+            percentiles: Pct0Pct1Pct2Pct5Pct95Pct98Pct99Pattern::new(client.clone(), "rookie_realized_price".to_string()),
+            sma: _1m1w1y2y4yAllPattern::new(client.clone(), "rookie_realized_price_ratio_sma".to_string()),
+            std_dev: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev::new(client.clone(), format!("{base_path}_std_dev")),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev {
+    pub all: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_All,
+    pub _4y: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_4y,
+    pub _2y: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_2y,
+    pub _1y: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_1y,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            all: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_All::new(client.clone(), format!("{base_path}_all")),
+            _4y: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_4y::new(client.clone(), format!("{base_path}_4y")),
+            _2y: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_2y::new(client.clone(), format!("{base_path}_2y")),
+            _1y: SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_1y::new(client.clone(), format!("{base_path}_1y")),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_All {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_All {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_sd".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_zscore".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "rookie_realized_price_0sd".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p0_5sd".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1sd".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1_5sd".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2sd".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2_5sd".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p3sd".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m0_5sd".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1sd".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1_5sd".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2sd".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2_5sd".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m3sd".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_4y {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_4y {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_sd_4y".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_zscore_4y".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "rookie_realized_price_0sd_4y".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p0_5sd_4y".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1sd_4y".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1_5sd_4y".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2sd_4y".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2_5sd_4y".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p3sd_4y".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m0_5sd_4y".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1sd_4y".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1_5sd_4y".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2sd_4y".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2_5sd_4y".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m3sd_4y".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_2y {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_2y {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_sd_2y".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_zscore_2y".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "rookie_realized_price_0sd_2y".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p0_5sd_2y".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1sd_2y".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1_5sd_2y".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2sd_2y".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2_5sd_2y".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p3sd_2y".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m0_5sd_2y".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1sd_2y".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1_5sd_2y".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2sd_2y".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2_5sd_2y".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m3sd_2y".to_string()),
+        }
+    }
+}
+
+/// Series tree node.
+pub struct SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_1y {
+    pub sd: SeriesPattern1<StoredF32>,
+    pub zscore: SeriesPattern1<StoredF32>,
+    pub _0sd: CentsSatsUsdPattern,
+    pub p0_5sd: PriceRatioPattern,
+    pub p1sd: PriceRatioPattern,
+    pub p1_5sd: PriceRatioPattern,
+    pub p2sd: PriceRatioPattern,
+    pub p2_5sd: PriceRatioPattern,
+    pub p3sd: PriceRatioPattern,
+    pub m0_5sd: PriceRatioPattern,
+    pub m1sd: PriceRatioPattern,
+    pub m1_5sd: PriceRatioPattern,
+    pub m2sd: PriceRatioPattern,
+    pub m2_5sd: PriceRatioPattern,
+    pub m3sd: PriceRatioPattern,
+}
+
+impl SeriesTree_Cohorts_Utxo_Entry_Premium_Realized_Price_StdDev_1y {
+    pub fn new(client: Arc<BrkClientBase>, base_path: String) -> Self {
+        Self {
+            sd: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_sd_1y".to_string()),
+            zscore: SeriesPattern1::new(client.clone(), "rookie_realized_price_ratio_zscore_1y".to_string()),
+            _0sd: CentsSatsUsdPattern::new(client.clone(), "rookie_realized_price_0sd_1y".to_string()),
+            p0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p0_5sd_1y".to_string()),
+            p1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1sd_1y".to_string()),
+            p1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p1_5sd_1y".to_string()),
+            p2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2sd_1y".to_string()),
+            p2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p2_5sd_1y".to_string()),
+            p3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "p3sd_1y".to_string()),
+            m0_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m0_5sd_1y".to_string()),
+            m1sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1sd_1y".to_string()),
+            m1_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m1_5sd_1y".to_string()),
+            m2sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2sd_1y".to_string()),
+            m2_5sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m2_5sd_1y".to_string()),
+            m3sd: PriceRatioPattern::new(client.clone(), "rookie_realized_price".to_string(), "m3sd_1y".to_string()),
+        }
+    }
+}
+
 /// Series tree node.
 pub struct SeriesTree_Cohorts_Utxo_OverAmount {
     pub _1sat: ActivityOutputsRealizedSupplyUnrealizedPattern2,
@@ -8953,7 +9538,7 @@ pub struct BrkClient {
 
 impl BrkClient {
     /// Client version.
-    pub const VERSION: &'static str = "v0.3.0-beta.7";
+    pub const VERSION: &'static str = "v0.3.4";
 
     /// Create a new client with the given base URL.
     pub fn new(base_url: impl Into<String>) -> Self {
@@ -9009,7 +9594,7 @@ impl BrkClient {
 
     /// Health check
     ///
-    /// Returns the health status of the API server, including uptime information.
+    /// Liveness probe. Returns server identity, uptime, and indexed/computed heights from local state only (no bitcoind round-trip). For real chain-tip catch-up, see `/api/server/sync`.
     ///
     /// Endpoint: `GET /health`
     pub fn get_health(&self) -> Result<Health> {
@@ -9281,6 +9866,15 @@ impl BrkClient {
         self.base.get_json(&path)
     }
 
+    /// Address hash-prefix matches
+    ///
+    /// Find addresses by address type and address-payload hash prefix. Intended for privacy-preserving client-side wallet discovery without sending raw addresses or xpubs. Fetch metadata for the returned addresses through `/api/address/{address}`.
+    ///
+    /// Endpoint: `GET /api/address/hash-prefix/{addr_type}/{prefix}`
+    pub fn get_address_hash_prefix_matches(&self, addr_type: OutputType, prefix: &str) -> Result<AddrHashPrefixMatches> {
+        self.base.get_json(&format!("/api/address/hash-prefix/{addr_type}/{prefix}"))
+    }
+
     /// Address information
     ///
     /// Retrieve address information including balance and transaction counts. Supports all standard Bitcoin address types (P2PKH, P2SH, P2WPKH, P2WSH, P2TR).
@@ -9294,7 +9888,7 @@ impl BrkClient {
 
     /// Address transactions
     ///
-    /// Get transaction history for an address, sorted with newest first. Returns up to 50 entries: mempool transactions first, then confirmed transactions filling the remainder. To paginate further confirmed transactions, use `/address/{address}/txs/chain/{last_seen_txid}`.
+    /// Get transaction history for an address, newest first. Returns up to 50 mempool transactions plus a confirmed page sized to fill the response to 50 total (chain floor of 25, so 25-50 confirmed depending on mempool weight). To paginate further confirmed history, use `/address/{address}/txs/chain/{last_seen_txid}`.
     ///
     /// *[Mempool.space docs](https://mempool.space/docs/api/rest#get-address-transactions)*
     ///
@@ -9734,7 +10328,7 @@ impl BrkClient {
 
     /// Projected mempool blocks
     ///
-    /// Get projected blocks from the mempool for fee estimation.
+    /// Projected blocks for fee estimation. Block 0 reflects Bitcoin Core's actual next-block selection; blocks 1+ are a fee-tier approximation.
     ///
     /// *[Mempool.space docs](https://mempool.space/docs/api/rest#get-mempool-blocks-fees)*
     ///
@@ -9745,7 +10339,7 @@ impl BrkClient {
 
     /// Recommended fees
     ///
-    /// Get recommended fee rates for different confirmation targets.
+    /// Recommended fee rates by confirmation target.
     ///
     /// *[Mempool.space docs](https://mempool.space/docs/api/rest#get-recommended-fees)*
     ///
@@ -9756,7 +10350,7 @@ impl BrkClient {
 
     /// Precise recommended fees
     ///
-    /// Get recommended fee rates with up to 3 decimal places.
+    /// Recommended fee rates with sub-integer precision.
     ///
     /// *[Mempool.space docs](https://mempool.space/docs/api/rest#get-recommended-fees-precise)*
     ///
@@ -9778,10 +10372,10 @@ impl BrkClient {
 
     /// Mempool content hash
     ///
-    /// Returns an opaque `u64` that changes whenever the projected next block changes. Same value as the mempool ETag. Useful as a freshness/liveness signal: if it stays constant for tens of seconds on a live network, the mempool sync loop has stalled.
+    /// Returns an opaque hash that changes whenever the projected next block changes. Same value as the mempool ETag. Useful as a freshness/liveness signal: if it stays constant for tens of seconds on a live network, the mempool sync loop has stalled.
     ///
     /// Endpoint: `GET /api/mempool/hash`
-    pub fn get_mempool_hash(&self) -> Result<i64> {
+    pub fn get_mempool_hash(&self) -> Result<NextBlockHash> {
         self.base.get_json(&format!("/api/mempool/hash"))
     }
 
@@ -9829,6 +10423,24 @@ impl BrkClient {
         self.base.get_json(&format!("/api/v1/fullrbf/replacements"))
     }
 
+    /// Projected next block template
+    ///
+    /// Bitcoin Core's `getblocktemplate` selection: full transaction bodies in GBT order with aggregate stats. The returned `hash` is an opaque content token; pass it as `<hash>` on `/api/v1/mempool/block-template/diff/{hash}` to fetch deltas instead of refetching the whole template.
+    ///
+    /// Endpoint: `GET /api/v1/mempool/block-template`
+    pub fn get_block_template(&self) -> Result<BlockTemplate> {
+        self.base.get_json(&format!("/api/v1/mempool/block-template"))
+    }
+
+    /// Block template diff since hash
+    ///
+    /// Delta of the projected next block since `<hash>`. `order` is the full new template in order: each entry is either a number (index into the prior template the client cached at `<hash>`) or a transaction object (new body to insert at this position). Walk `order` once to rebuild; `removed` is a convenience list of txids that left so clients can evict cached bodies. After applying, use the response `hash` as `<hash>` on the next call to keep iterating. Returns `404` when `<hash>` has aged out of server history; clients should fall back to `/api/v1/mempool/block-template`.
+    ///
+    /// Endpoint: `GET /api/v1/mempool/block-template/diff/{hash}`
+    pub fn get_block_template_diff(&self, hash: NextBlockHash) -> Result<BlockTemplateDiff> {
+        self.base.get_json(&format!("/api/v1/mempool/block-template/diff/{hash}"))
+    }
+
     /// Live BTC/USD price
     ///
     /// Returns the current BTC/USD price in dollars, derived from on-chain round-dollar output patterns in the last 12 blocks plus mempool.
@@ -9838,6 +10450,51 @@ impl BrkClient {
         self.base.get_json(&format!("/api/mempool/price"))
     }
 
+    /// Live BTC/USD price
+    ///
+    /// Current BTC/USD price in dollars. Same value as `/api/mempool/price`. Confirmed per-height history is available at `/api/vecs/height-to-price`.
+    ///
+    /// Endpoint: `GET /api/oracle/price`
+    pub fn get_oracle_price(&self) -> Result<Dollars> {
+        self.base.get_json(&format!("/api/oracle/price"))
+    }
+
+    /// Live payment output histogram
+    ///
+    /// Live smoothed histogram of oracle-eligible payment outputs, binned by output value on the oracle log scale. It combines the committed oracle window with the forming mempool block. A flat array of log-scale bins.
+    ///
+    /// Endpoint: `GET /api/oracle/histogram/payments/live`
+    pub fn get_oracle_histogram_payments_live(&self) -> Result<Vec<i64>> {
+        self.base.get_json(&format!("/api/oracle/histogram/payments/live"))
+    }
+
+    /// Payment output histogram at height or day
+    ///
+    /// Smoothed histogram of oracle-eligible payment outputs for a confirmed point. A block height (`840000`) gives that block's oracle payment histogram; a calendar date (`YYYY-MM-DD`) gives the average of that day's per-block payment histograms. A flat array of log-scale bins.
+    ///
+    /// Endpoint: `GET /api/oracle/histogram/payments/{point}`
+    pub fn get_oracle_histogram_payments(&self, point: &str) -> Result<Vec<i64>> {
+        self.base.get_json(&format!("/api/oracle/histogram/payments/{point}"))
+    }
+
+    /// Live output value histogram
+    ///
+    /// Live unfiltered output value histogram for the forming mempool block. Every live output is binned by value on the oracle log scale; no oracle payment filters are applied. A flat array of log-scale bins, all zero when no mempool is configured.
+    ///
+    /// Endpoint: `GET /api/oracle/histogram/outputs/live`
+    pub fn get_oracle_histogram_outputs_live(&self) -> Result<Vec<i64>> {
+        self.base.get_json(&format!("/api/oracle/histogram/outputs/live"))
+    }
+
+    /// Output value histogram at height or day
+    ///
+    /// Unfiltered output value histogram for a confirmed point. A block height (`840000`) gives every output in that block, coinbase included, binned by value on the oracle log scale; a calendar date (`YYYY-MM-DD`) sums every block that day. A flat array of log-scale bins.
+    ///
+    /// Endpoint: `GET /api/oracle/histogram/outputs/{point}`
+    pub fn get_oracle_histogram_outputs(&self, point: &str) -> Result<Vec<i64>> {
+        self.base.get_json(&format!("/api/oracle/histogram/outputs/{point}"))
+    }
+
     /// Txid by index
     ///
     /// Retrieve the transaction ID (txid) at a given global transaction index. Returns the txid as plain text.

crates/brk_cohort/src/by_entry.rs

@@ -0,0 +1,104 @@
+use brk_traversable::Traversable;
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use serde::Serialize;
+
+use super::{CohortName, Filter};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EntryPrice {
+    Discount,
+    Premium,
+}
+
+impl EntryPrice {
+    #[inline]
+    pub const fn from_is_discount(is_discount: bool) -> Self {
+        if is_discount {
+            Self::Discount
+        } else {
+            Self::Premium
+        }
+    }
+
+    #[inline]
+    pub const fn is_discount(self) -> bool {
+        matches!(self, Self::Discount)
+    }
+}
+
+pub const ENTRY_FILTERS: ByEntry<Filter> = ByEntry {
+    discount: Filter::Entry(EntryPrice::Discount),
+    premium: Filter::Entry(EntryPrice::Premium),
+};
+
+pub const ENTRY_NAMES: ByEntry<CohortName> = ByEntry {
+    discount: CohortName::new("veteran", "Veteran", "Veteran Coins"),
+    premium: CohortName::new("rookie", "Rookie", "Rookie Coins"),
+};
+
+#[derive(Default, Clone, Traversable, Serialize)]
+pub struct ByEntry<T> {
+    pub discount: T,
+    pub premium: T,
+}
+
+impl ByEntry<CohortName> {
+    pub const fn names() -> &'static Self {
+        &ENTRY_NAMES
+    }
+}
+
+impl<T> ByEntry<T> {
+    pub fn new<F>(mut create: F) -> Self
+    where
+        F: FnMut(Filter, &'static str) -> T,
+    {
+        let f = ENTRY_FILTERS;
+        let n = ENTRY_NAMES;
+        Self {
+            discount: create(f.discount, n.discount.id),
+            premium: create(f.premium, n.premium.id),
+        }
+    }
+
+    pub fn try_new<F, E>(mut create: F) -> Result<Self, E>
+    where
+        F: FnMut(Filter, &'static str) -> Result<T, E>,
+    {
+        let f = ENTRY_FILTERS;
+        let n = ENTRY_NAMES;
+        Ok(Self {
+            discount: create(f.discount, n.discount.id)?,
+            premium: create(f.premium, n.premium.id)?,
+        })
+    }
+
+    pub fn get(&self, entry: EntryPrice) -> &T {
+        match entry {
+            EntryPrice::Discount => &self.discount,
+            EntryPrice::Premium => &self.premium,
+        }
+    }
+
+    pub fn get_mut(&mut self, entry: EntryPrice) -> &mut T {
+        match entry {
+            EntryPrice::Discount => &mut self.discount,
+            EntryPrice::Premium => &mut self.premium,
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &T> {
+        [&self.discount, &self.premium].into_iter()
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
+        [&mut self.discount, &mut self.premium].into_iter()
+    }
+
+    pub fn par_iter_mut(&mut self) -> impl ParallelIterator<Item = &mut T>
+    where
+        T: Send + Sync,
+    {
+        [&mut self.discount, &mut self.premium].into_par_iter()
+    }
+}

crates/brk_cohort/src/cohort_context.rs

@@ -24,7 +24,7 @@ impl CohortContext {
     /// Build full name for a filter, adding prefix only for Time/Amount filters.
     ///
     /// Prefix rules:
-    /// - No prefix: `All`, `Term`, `Epoch`, `Class`, `Type`
+    /// - No prefix: `All`, `Term`, `Epoch`, `Class`, `Entry`, `Type`
     /// - Context prefix: `Time`, `Amount`
     pub fn full_name(&self, filter: &Filter, name: &str) -> String {
         match filter {
@@ -32,6 +32,7 @@ impl CohortContext {
             | Filter::Term(_)
             | Filter::Epoch(_)
             | Filter::Class(_)
+            | Filter::Entry(_)
             | Filter::Type(_) => name.to_string(),
             Filter::Time(_) | Filter::Amount(_) => self.prefixed(name),
         }

crates/brk_cohort/src/filter.rs

@@ -1,6 +1,6 @@
 use brk_types::{Halving, OutputType, Sats, Year};
 
-use super::{AmountFilter, CohortContext, Term, TimeFilter};
+use super::{AmountFilter, CohortContext, EntryPrice, Term, TimeFilter};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Filter {
@@ -10,6 +10,7 @@ pub enum Filter {
     Amount(AmountFilter),
     Epoch(Halving),
     Class(Year),
+    Entry(EntryPrice),
     Type(OutputType),
 }
 
@@ -68,7 +69,8 @@ impl Filter {
     }
 
     /// Whether to compute extended metrics (realized cap ratios, profit/loss ratios, percentiles)
-    /// For UTXO context: true only for age range cohorts (Range) and aggregate cohorts (All, Term)
+    /// For UTXO context: true for age range cohorts (Range), aggregate cohorts (All, Term),
+    /// and immutable entry valuation cohorts.
     /// For address context: always false
     pub fn is_extended(&self, context: CohortContext) -> bool {
         match context {
@@ -76,7 +78,10 @@ impl Filter {
             CohortContext::Utxo => {
                 matches!(
                     self,
-                    Filter::All | Filter::Term(_) | Filter::Time(TimeFilter::Range(_))
+                    Filter::All
+                        | Filter::Term(_)
+                        | Filter::Time(TimeFilter::Range(_))
+                        | Filter::Entry(_)
                 )
             }
         }

crates/brk_cohort/src/lib.rs

@@ -7,6 +7,7 @@ mod amount_range;
 mod by_addr_type;
 mod by_any_addr;
 mod by_epoch;
+mod by_entry;
 mod by_term;
 mod by_type;
 mod class;
@@ -36,6 +37,7 @@ pub use amount_range::*;
 pub use by_addr_type::*;
 pub use by_any_addr::*;
 pub use by_epoch::*;
+pub use by_entry::*;
 pub use by_term::*;
 pub use by_type::*;
 pub use class::*;

crates/brk_cohort/src/utxo.rs

@@ -2,8 +2,8 @@ use brk_traversable::Traversable;
 use rayon::prelude::*;
 
 use crate::{
-    AgeRange, AmountRange, ByEpoch, ByTerm, Class, Filter, OverAge, OverAmount, SpendableType,
-    UnderAge, UnderAmount,
+    AgeRange, AmountRange, ByEntry, ByEpoch, ByTerm, Class, Filter, OverAge, OverAmount,
+    SpendableType, UnderAge, UnderAmount,
 };
 
 #[derive(Default, Clone, Traversable)]
@@ -12,6 +12,7 @@ pub struct UTXOGroups<T> {
     pub age_range: AgeRange<T>,
     pub epoch: ByEpoch<T>,
     pub class: Class<T>,
+    pub entry: ByEntry<T>,
     pub over_age: OverAge<T>,
     pub over_amount: OverAmount<T>,
     pub amount_range: AmountRange<T>,
@@ -31,6 +32,7 @@ impl<T> UTXOGroups<T> {
             age_range: AgeRange::new(&mut create),
             epoch: ByEpoch::new(&mut create),
             class: Class::new(&mut create),
+            entry: ByEntry::new(&mut create),
             over_age: OverAge::new(&mut create),
             over_amount: OverAmount::new(&mut create),
             amount_range: AmountRange::new(&mut create),
@@ -51,6 +53,7 @@ impl<T> UTXOGroups<T> {
             .chain(self.age_range.iter())
             .chain(self.epoch.iter())
             .chain(self.class.iter())
+            .chain(self.entry.iter())
             .chain(self.amount_range.iter())
             .chain(self.under_amount.iter())
             .chain(self.type_.iter())
@@ -66,6 +69,7 @@ impl<T> UTXOGroups<T> {
             .chain(self.age_range.iter_mut())
             .chain(self.epoch.iter_mut())
             .chain(self.class.iter_mut())
+            .chain(self.entry.iter_mut())
             .chain(self.amount_range.iter_mut())
             .chain(self.under_amount.iter_mut())
             .chain(self.type_.iter_mut())
@@ -84,6 +88,7 @@ impl<T> UTXOGroups<T> {
             .chain(self.age_range.par_iter_mut())
             .chain(self.epoch.par_iter_mut())
             .chain(self.class.par_iter_mut())
+            .chain(self.entry.par_iter_mut())
             .chain(self.amount_range.par_iter_mut())
             .chain(self.under_amount.par_iter_mut())
             .chain(self.type_.par_iter_mut())
@@ -94,6 +99,7 @@ impl<T> UTXOGroups<T> {
             .iter()
             .chain(self.epoch.iter())
             .chain(self.class.iter())
+            .chain(self.entry.iter())
             .chain(self.amount_range.iter())
             .chain(self.type_.iter())
     }
@@ -103,6 +109,7 @@ impl<T> UTXOGroups<T> {
             .iter_mut()
             .chain(self.epoch.iter_mut())
             .chain(self.class.iter_mut())
+            .chain(self.entry.iter_mut())
             .chain(self.amount_range.iter_mut())
             .chain(self.type_.iter_mut())
     }
@@ -115,6 +122,7 @@ impl<T> UTXOGroups<T> {
             .par_iter_mut()
             .chain(self.epoch.par_iter_mut())
             .chain(self.class.par_iter_mut())
+            .chain(self.entry.par_iter_mut())
             .chain(self.amount_range.par_iter_mut())
             .chain(self.type_.par_iter_mut())
     }

crates/brk_computer/src/cointime/compute.rs

@@ -3,14 +3,14 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, distribution, mining, prices, supply};
+use crate::{blocks, distribution, mining, price, supply};
 
 impl Vecs {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         blocks: &blocks::Vecs,
         mining: &mining::Vecs,
         supply_vecs: &supply::Vecs,

crates/brk_computer/src/cointime/prices/compute.rs

@@ -5,14 +5,14 @@ use vecdb::Exit;
 
 use super::super::{activity, cap, supply};
 use super::Vecs;
-use crate::{distribution, prices};
+use crate::{distribution, price};
 
 impl Vecs {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         distribution: &distribution::Vecs,
         activity: &activity::Vecs,
         supply: &supply::Vecs,

crates/brk_computer/src/cointime/reserve_risk/compute.rs

@@ -4,14 +4,14 @@ use brk_types::StoredF64;
 use vecdb::Exit;
 
 use super::{super::value, Vecs};
-use crate::{blocks, internal::algo::ComputeRollingMedianFromStarts, prices};
+use crate::{blocks, internal::algo::ComputeRollingMedianFromStarts, price};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         value: &value::Vecs,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/cointime/supply/compute.rs

@@ -4,13 +4,13 @@ use vecdb::Exit;
 
 use super::super::activity;
 use super::Vecs;
-use crate::{distribution, prices};
+use crate::{distribution, price};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         distribution: &distribution::Vecs,
         activity: &activity::Vecs,
         exit: &Exit,

crates/brk_computer/src/cointime/value/compute.rs

@@ -5,13 +5,13 @@ use vecdb::Exit;
 
 use super::super::activity;
 use super::Vecs;
-use crate::{distribution, prices};
+use crate::{distribution, price};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         distribution: &distribution::Vecs,
         activity: &activity::Vecs,
         exit: &Exit,

crates/brk_computer/src/distribution/addr/exposed/mod.rs

@@ -45,7 +45,7 @@ use super::{
     count::AddrCountFundedTotalVecs,
     supply::{AddrSupplyShareVecs, AddrSupplyVecs},
 };
-use crate::{indexes, prices};
+use crate::{indexes, price};
 
 mod state;
 
@@ -104,7 +104,7 @@ impl ExposedAddrVecs {
     pub(crate) fn compute_rest(
         &mut self,
         starting_lengths: &Lengths,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         type_supply_sats: &ByAddrType<&impl ReadableVec<Height, Sats>>,
         exit: &Exit,

crates/brk_computer/src/distribution/addr/reused/mod.rs

@@ -35,7 +35,7 @@ use super::{
 use crate::{
     indexes, inputs,
     internal::{WindowStartVec, Windows},
-    outputs, prices,
+    outputs, price,
 };
 
 mod state;
@@ -112,7 +112,7 @@ impl ReusedAddrVecs {
         starting_lengths: &Lengths,
         outputs_by_type: &outputs::ByTypeVecs,
         inputs_by_type: &inputs::ByTypeVecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         type_supply_sats: &ByAddrType<&impl ReadableVec<Height, Sats>>,
         exit: &Exit,

crates/brk_computer/src/distribution/cohorts/addr/groups.rs

@@ -13,7 +13,7 @@ use crate::{
     distribution::DynCohortVecs,
     indexes,
     internal::{WindowStartVec, Windows},
-    prices,
+    price,
 };
 
 use super::{super::traits::CohortVecs, vecs::AddrCohortVecs};
@@ -95,7 +95,7 @@ impl AddrCohorts {
     /// First phase of post-processing: compute index transforms.
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -108,7 +108,7 @@ impl AddrCohorts {
     /// Second phase of post-processing: compute relative metrics.
     pub(crate) fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         all_utxo_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/cohorts/addr/vecs.rs

@@ -12,7 +12,7 @@ use crate::{
     distribution::state::{AddrCohortState, MinimalRealizedState},
     indexes,
     internal::{PerBlockWithDeltas, WindowStartVec, Windows},
-    prices,
+    price,
 };
 
 use crate::distribution::metrics::{ImportConfig, MinimalCohortMetrics};
@@ -174,7 +174,7 @@ impl DynCohortVecs for AddrCohortVecs {
 
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -229,7 +229,7 @@ impl CohortVecs for AddrCohortVecs {
 
     fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         all_utxo_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/cohorts/traits.rs

@@ -3,7 +3,7 @@ use brk_indexer::Lengths;
 use brk_types::{Cents, Height, Sats, StoredU64, Version};
 use vecdb::{Exit, ReadableVec};
 
-use crate::prices;
+use crate::price;
 
 /// Dynamic dispatch trait for cohort vectors.
 ///
@@ -31,7 +31,7 @@ pub trait DynCohortVecs: Send + Sync {
     /// First phase of post-processing computations.
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()>;
@@ -61,7 +61,7 @@ pub trait CohortVecs: DynCohortVecs {
     /// Second phase of post-processing computations.
     fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         all_utxo_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/cohorts/utxo/fenwick.rs

@@ -30,18 +30,34 @@ const TREE_SIZE: usize = TIER0_COUNT + TIER1_COUNT + OVERFLOW; // 190,001
 pub(super) struct CostBasisNode {
     all_sats: i64,
     sth_sats: i64,
+    discount_sats: i64,
     all_usd: i128,
     sth_usd: i128,
+    discount_usd: i128,
 }
 
 impl CostBasisNode {
     #[inline(always)]
-    fn new(sats: i64, usd: i128, is_sth: bool) -> Self {
+    fn new_supply(sats: i64, usd: i128, is_sth: bool) -> Self {
         Self {
             all_sats: sats,
             sth_sats: if is_sth { sats } else { 0 },
+            discount_sats: 0,
             all_usd: usd,
             sth_usd: if is_sth { usd } else { 0 },
+            discount_usd: 0,
+        }
+    }
+
+    #[inline(always)]
+    fn new_discount(sats: i64, usd: i128) -> Self {
+        Self {
+            all_sats: 0,
+            sth_sats: 0,
+            discount_sats: sats,
+            all_usd: 0,
+            sth_usd: 0,
+            discount_usd: usd,
         }
     }
 }
@@ -51,8 +67,10 @@ impl FenwickNode for CostBasisNode {
     fn add_assign(&mut self, other: &Self) {
         self.all_sats += other.all_sats;
         self.sth_sats += other.sth_sats;
+        self.discount_sats += other.discount_sats;
         self.all_usd += other.all_usd;
         self.sth_usd += other.sth_usd;
+        self.discount_usd += other.discount_usd;
     }
 }
 
@@ -151,16 +169,34 @@ impl CostBasisFenwick {
         }
         let bucket = price_to_bucket(price);
         let delta =
-            CostBasisNode::new(net_sats, price.as_u128() as i128 * net_sats as i128, is_sth);
+            CostBasisNode::new_supply(net_sats, price.as_u128() as i128 * net_sats as i128, is_sth);
         self.tree.add(bucket, &delta);
         self.totals.add_assign(&delta);
     }
 
-    /// Bulk-initialize from BTreeMaps (one per age-range cohort).
-    /// Call after state import when all pending maps have been drained.
-    pub(super) fn bulk_init<'a>(
+    /// Apply a net delta from the discount-entry cohort.
+    ///
+    /// Supply totals are maintained from the age-range cohorts; this updates
+    /// only the discount-entry partition so premium can be derived as all - discount.
+    pub(super) fn apply_discount_delta(&mut self, price: CentsCompact, pending: &PendingDelta) {
+        let net_sats = u64::from(pending.inc) as i64 - u64::from(pending.dec) as i64;
+        if net_sats == 0 {
+            return;
+        }
+        let bucket = price_to_bucket(price);
+        let delta =
+            CostBasisNode::new_discount(net_sats, price.as_u128() as i128 * net_sats as i128);
+        self.tree.add(bucket, &delta);
+        self.totals.add_assign(&delta);
+    }
+
+    /// Bulk-initialize from age-range maps plus the discount-entry map.
+    /// Age-range maps maintain all/STH/LTH totals; the discount-entry map
+    /// maintains only the discount partition used to derive premium.
+    pub(super) fn bulk_init_with_discount<'a>(
         &mut self,
         maps: impl Iterator<Item = (&'a std::collections::BTreeMap<CentsCompact, Sats>, bool)>,
+        discount_maps: impl Iterator<Item = &'a std::collections::BTreeMap<CentsCompact, Sats>>,
     ) {
         self.tree.reset();
         self.totals = CostBasisNode::default();
@@ -169,7 +205,18 @@ impl CostBasisFenwick {
             for (&price, &sats) in map.iter() {
                 let bucket = price_to_bucket(price);
                 let s = u64::from(sats) as i64;
-                let node = CostBasisNode::new(s, price.as_u128() as i128 * s as i128, is_sth);
+                let node =
+                    CostBasisNode::new_supply(s, price.as_u128() as i128 * s as i128, is_sth);
+                self.tree.add_raw(bucket, &node);
+                self.totals.add_assign(&node);
+            }
+        }
+
+        for map in discount_maps {
+            for (&price, &sats) in map.iter() {
+                let bucket = price_to_bucket(price);
+                let s = u64::from(sats) as i64;
+                let node = CostBasisNode::new_discount(s, price.as_u128() as i128 * s as i128);
                 self.tree.add_raw(bucket, &node);
                 self.totals.add_assign(&node);
             }
@@ -212,6 +259,26 @@ impl CostBasisFenwick {
         )
     }
 
+    /// Compute percentile prices for discount-entry cohort.
+    pub(super) fn percentiles_discount_entry(&self) -> PercentileResult {
+        self.compute_percentiles(
+            self.totals.discount_sats,
+            self.totals.discount_usd,
+            |n| n.discount_sats,
+            |n| n.discount_usd,
+        )
+    }
+
+    /// Compute percentile prices for premium-entry cohort (all - discount).
+    pub(super) fn percentiles_premium_entry(&self) -> PercentileResult {
+        self.compute_percentiles(
+            self.totals.all_sats - self.totals.discount_sats,
+            self.totals.all_usd - self.totals.discount_usd,
+            |n| n.all_sats - n.discount_sats,
+            |n| n.all_usd - n.discount_usd,
+        )
+    }
+
     fn compute_percentiles(
         &self,
         total_sats: i64,
@@ -271,6 +338,37 @@ impl CostBasisFenwick {
             return (0, 0, 0);
         }
 
+        let range = self.density_range(spot_price);
+        let all_range = range.all_sats.max(0);
+        let sth_range = range.sth_sats.max(0);
+        let lth_range = all_range - sth_range;
+
+        let lth_total = self.totals.all_sats - self.totals.sth_sats;
+        (
+            Self::to_bps(all_range, self.totals.all_sats),
+            Self::to_bps(sth_range, self.totals.sth_sats),
+            Self::to_bps(lth_range, lth_total),
+        )
+    }
+
+    /// Compute supply density for entry cohorts: (discount_bps, premium_bps).
+    pub(super) fn entry_density(&self, spot_price: Cents) -> (u16, u16) {
+        if self.totals.all_sats <= 0 {
+            return (0, 0);
+        }
+
+        let range = self.density_range(spot_price);
+        let discount_range = range.discount_sats.max(0);
+        let premium_range = range.all_sats.max(0) - discount_range;
+        let premium_total = self.totals.all_sats - self.totals.discount_sats;
+
+        (
+            Self::to_bps(discount_range, self.totals.discount_sats),
+            Self::to_bps(premium_range, premium_total),
+        )
+    }
+
+    fn density_range(&self, spot_price: Cents) -> CostBasisNode {
         let spot_f64 = u64::from(spot_price) as f64;
         let low = Cents::from((spot_f64 * 0.95) as u64);
         let high = Cents::from((spot_f64 * 1.05) as u64);
@@ -285,24 +383,23 @@ impl CostBasisFenwick {
             CostBasisNode::default()
         };
 
-        let all_range = (cum_high.all_sats - cum_low.all_sats).max(0);
-        let sth_range = (cum_high.sth_sats - cum_low.sth_sats).max(0);
-        let lth_range = all_range - sth_range;
+        CostBasisNode {
+            all_sats: cum_high.all_sats - cum_low.all_sats,
+            sth_sats: cum_high.sth_sats - cum_low.sth_sats,
+            discount_sats: cum_high.discount_sats - cum_low.discount_sats,
+            all_usd: cum_high.all_usd - cum_low.all_usd,
+            sth_usd: cum_high.sth_usd - cum_low.sth_usd,
+            discount_usd: cum_high.discount_usd - cum_low.discount_usd,
+        }
+    }
 
-        let to_bps = |range: i64, total: i64| -> u16 {
-            if total <= 0 {
-                0
-            } else {
-                (range as f64 / total as f64 * 10000.0).round() as u16
-            }
-        };
-
-        let lth_total = self.totals.all_sats - self.totals.sth_sats;
-        (
-            to_bps(all_range, self.totals.all_sats),
-            to_bps(sth_range, self.totals.sth_sats),
-            to_bps(lth_range, lth_total),
-        )
+    #[inline(always)]
+    fn to_bps(range: i64, total: i64) -> u16 {
+        if total <= 0 {
+            0
+        } else {
+            (range as f64 / total as f64 * 10000.0).round() as u16
+        }
     }
 
     // -----------------------------------------------------------------------

crates/brk_computer/src/distribution/cohorts/utxo/groups.rs

@@ -1,8 +1,8 @@
 use std::path::Path;
 
 use brk_cohort::{
-    AgeRange, AmountRange, ByEpoch, Class, CohortContext, Filter, Filtered, OverAge, OverAmount,
-    SpendableType, Term, UnderAge, UnderAmount,
+    AgeRange, AmountRange, ByEntry, ByEpoch, Class, CohortContext, Filter, Filtered, OverAge,
+    OverAmount, SpendableType, Term, UnderAge, UnderAmount,
 };
 use brk_error::Result;
 use brk_indexer::Lengths;
@@ -16,7 +16,6 @@ use vecdb::{
 use crate::{
     blocks,
     distribution::{
-        DynCohortVecs,
         metrics::{
             AllCohortMetrics, BasicCohortMetrics, CohortMetricsBase, CoreCohortMetrics,
             ExtendedAdjustedCohortMetrics, ExtendedCohortMetrics, ImportConfig,
@@ -24,10 +23,11 @@ use crate::{
             TypeCohortMetrics,
         },
         state::UTXOCohortState,
+        DynCohortVecs,
     },
     indexes,
     internal::{ValuePerBlockCumulativeRolling, WindowStartVec, Windows},
-    prices,
+    price,
 };
 
 use super::{fenwick::CostBasisFenwick, vecs::UTXOCohortVecs};
@@ -45,6 +45,7 @@ pub struct UTXOCohorts<M: StorageMode = Rw> {
     pub over_age: OverAge<UTXOCohortVecs<CoreCohortMetrics<M>>>,
     pub epoch: ByEpoch<UTXOCohortVecs<CoreCohortMetrics<M>>>,
     pub class: Class<UTXOCohortVecs<CoreCohortMetrics<M>>>,
+    pub entry: ByEntry<UTXOCohortVecs<ExtendedCohortMetrics<M>>>,
     pub over_amount: OverAmount<UTXOCohortVecs<MinimalCohortMetrics<M>>>,
     pub amount_range: AmountRange<UTXOCohortVecs<MinimalCohortMetrics<M>>>,
     pub under_amount: UnderAmount<UTXOCohortVecs<MinimalCohortMetrics<M>>>,
@@ -67,8 +68,10 @@ pub(crate) struct UTXOCohortsTransientState {
 }
 
 impl UTXOCohorts<Rw> {
-    /// ~71 separate cohorts (21 age + 5 epoch + 18 class + 15 amount + 12 type)
-    const SEPARATE_COHORT_CAPACITY: usize = 80;
+    /// Separate cohorts currently total 72:
+    /// 21 age + 5 epoch + 18 class + 2 entry + 15 amount + 11 spendable type.
+    /// Keep small headroom because this is only Vec allocation capacity.
+    const SEPARATE_COHORT_CAPACITY: usize = 82;
 
     /// Import all UTXO cohorts from database.
     pub(crate) fn forced_import(
@@ -136,6 +139,26 @@ impl UTXOCohorts<Rw> {
         let epoch = ByEpoch::try_new(&core_separate)?;
         let class = Class::try_new(&core_separate)?;
 
+        let extended_separate =
+            |f: Filter, name: &'static str| -> Result<UTXOCohortVecs<ExtendedCohortMetrics>> {
+                let full_name = CohortContext::Utxo.full_name(&f, name);
+                let cfg = ImportConfig {
+                    db,
+                    filter: &f,
+                    full_name: &full_name,
+                    version: v,
+                    indexes,
+                    cached_starts,
+                };
+                let state = Some(Box::new(UTXOCohortState::new(states_path, &full_name)));
+                Ok(UTXOCohortVecs::new(
+                    state,
+                    ExtendedCohortMetrics::forced_import(&cfg)?,
+                ))
+            };
+
+        let entry = ByEntry::try_new(&extended_separate)?;
+
         // Helper for separate cohorts with MinimalCohortMetrics + MinimalRealizedState
         let minimal_separate =
             |f: Filter, name: &'static str| -> Result<UTXOCohortVecs<MinimalCohortMetrics>> {
@@ -281,6 +304,7 @@ impl UTXOCohorts<Rw> {
             lth,
             epoch,
             class,
+            entry,
             type_,
             under_age,
             over_age,
@@ -309,6 +333,7 @@ impl UTXOCohorts<Rw> {
             sth,
             caches,
             age_range,
+            entry,
             ..
         } = self;
         caches
@@ -327,7 +352,15 @@ impl UTXOCohorts<Rw> {
                 Some((map, caches.fenwick.is_sth_at(i)))
             })
             .collect();
-        caches.fenwick.bulk_init(maps.into_iter());
+        let discount_maps = entry
+            .discount
+            .state
+            .as_ref()
+            .map(|state| state.cost_basis_map())
+            .into_iter();
+        caches
+            .fenwick
+            .bulk_init_with_discount(maps.into_iter(), discount_maps);
     }
 
     /// Apply pending deltas from all age-range cohorts to the Fenwick tree.
@@ -338,7 +371,10 @@ impl UTXOCohorts<Rw> {
         }
         // Destructure to get separate borrows on caches and age_range
         let Self {
-            caches, age_range, ..
+            caches,
+            age_range,
+            entry,
+            ..
         } = self;
         for (i, sub) in age_range.iter().enumerate() {
             if let Some(state) = sub.state.as_ref() {
@@ -348,6 +384,11 @@ impl UTXOCohorts<Rw> {
                 });
             }
         }
+        if let Some(state) = entry.discount.state.as_ref() {
+            state.for_each_cost_basis_pending(|&price, delta| {
+                caches.fenwick.apply_discount_delta(price, delta);
+            });
+        }
     }
 
     /// Push maturation sats to the matured vecs for the given height.
@@ -365,6 +406,7 @@ impl UTXOCohorts<Rw> {
             age_range,
             epoch,
             class,
+            entry,
             amount_range,
             type_,
             ..
@@ -374,6 +416,7 @@ impl UTXOCohorts<Rw> {
             .map(|x| x as &mut dyn DynCohortVecs)
             .chain(epoch.par_iter_mut().map(|x| x as &mut dyn DynCohortVecs))
             .chain(class.par_iter_mut().map(|x| x as &mut dyn DynCohortVecs))
+            .chain(entry.par_iter_mut().map(|x| x as &mut dyn DynCohortVecs))
             .chain(
                 amount_range
                     .par_iter_mut()
@@ -389,6 +432,7 @@ impl UTXOCohorts<Rw> {
             age_range,
             epoch,
             class,
+            entry,
             amount_range,
             type_,
             ..
@@ -398,6 +442,7 @@ impl UTXOCohorts<Rw> {
             .map(|x| x as &mut dyn DynCohortVecs)
             .chain(epoch.iter_mut().map(|x| x as &mut dyn DynCohortVecs))
             .chain(class.iter_mut().map(|x| x as &mut dyn DynCohortVecs))
+            .chain(entry.iter_mut().map(|x| x as &mut dyn DynCohortVecs))
             .chain(amount_range.iter_mut().map(|x| x as &mut dyn DynCohortVecs))
             .chain(type_.iter_mut().map(|x| x as &mut dyn DynCohortVecs))
     }
@@ -409,6 +454,7 @@ impl UTXOCohorts<Rw> {
             .map(|x| x as &dyn DynCohortVecs)
             .chain(self.epoch.iter().map(|x| x as &dyn DynCohortVecs))
             .chain(self.class.iter().map(|x| x as &dyn DynCohortVecs))
+            .chain(self.entry.iter().map(|x| x as &dyn DynCohortVecs))
             .chain(self.amount_range.iter().map(|x| x as &dyn DynCohortVecs))
             .chain(self.type_.iter().map(|x| x as &dyn DynCohortVecs))
     }
@@ -483,7 +529,7 @@ impl UTXOCohorts<Rw> {
     /// First phase of post-processing: compute index transforms.
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -516,6 +562,7 @@ impl UTXOCohorts<Rw> {
             );
             all.extend(self.epoch.iter_mut().map(|x| x as &mut dyn DynCohortVecs));
             all.extend(self.class.iter_mut().map(|x| x as &mut dyn DynCohortVecs));
+            all.extend(self.entry.iter_mut().map(|x| x as &mut dyn DynCohortVecs));
             all.extend(
                 self.amount_range
                     .iter_mut()
@@ -546,7 +593,7 @@ impl UTXOCohorts<Rw> {
     pub(crate) fn compute_rest_part2(
         &mut self,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         height_to_market_cap: &impl ReadableVec<Height, Dollars>,
         exit: &Exit,
@@ -604,6 +651,7 @@ impl UTXOCohorts<Rw> {
             under_amount,
             epoch,
             class,
+            entry,
             type_,
             ..
         } = self;
@@ -676,6 +724,19 @@ impl UTXOCohorts<Rw> {
                         .compute_rest_part2(prices, starting_lengths, ss, au, exit)
                 })
             }),
+            Box::new(|| {
+                entry.par_iter_mut().try_for_each(|v| {
+                    v.metrics.compute_rest_part2(
+                        blocks,
+                        prices,
+                        starting_lengths,
+                        height_to_market_cap,
+                        ss,
+                        au,
+                        exit,
+                    )
+                })
+            }),
             Box::new(|| {
                 amount_range.par_iter_mut().try_for_each(|v| {
                     v.metrics
@@ -730,6 +791,9 @@ impl UTXOCohorts<Rw> {
         for v in self.class.iter_mut() {
             vecs.extend(v.metrics.collect_all_vecs_mut());
         }
+        for v in self.entry.iter_mut() {
+            vecs.extend(v.metrics.collect_all_vecs_mut());
+        }
         for v in self.amount_range.iter_mut() {
             vecs.extend(v.metrics.collect_all_vecs_mut());
         }
@@ -813,7 +877,7 @@ impl UTXOCohorts<Rw> {
 
     /// Aggregate RealizedFull fields from age_range states and push to all/sth/lth.
     /// Called during the block loop after separate cohorts' push_state but before reset.
-    pub(crate) fn push_overlapping(&mut self, height_price: Cents) {
+    pub(crate) fn push_overlapping(&mut self, height_price: Cents) -> Cents {
         let Self {
             all,
             sth,
@@ -852,7 +916,7 @@ impl UTXOCohorts<Rw> {
             }
         }
 
-        all.metrics.realized.push_accum(&all_acc);
+        let all_capitalized_price = all.metrics.realized.push_accum(&all_acc);
         sth.metrics.realized.push_accum(&sth_acc);
         lth.metrics.realized.push_accum(&lth_acc);
 
@@ -880,6 +944,8 @@ impl UTXOCohorts<Rw> {
             .unrealized
             .capitalized_cap_in_loss_raw
             .push(CentsSquaredSats::new(lth_ccap.1));
+
+        all_capitalized_price
     }
 }
 

crates/brk_computer/src/distribution/cohorts/utxo/percentiles.rs

@@ -50,6 +50,22 @@ impl UTXOCohorts {
         let lth = self.caches.fenwick.percentiles_lth();
         push_cost_basis(&lth, lth_d, &mut self.lth.metrics.cost_basis);
 
+        let (discount_d, premium_d) = self.caches.fenwick.entry_density(spot_price);
+
+        let discount = self.caches.fenwick.percentiles_discount_entry();
+        push_cost_basis(
+            &discount,
+            discount_d,
+            &mut self.entry.discount.metrics.cost_basis,
+        );
+
+        let premium = self.caches.fenwick.percentiles_premium_entry();
+        push_cost_basis(
+            &premium,
+            premium_d,
+            &mut self.entry.premium.metrics.cost_basis,
+        );
+
         let prof = self.caches.fenwick.profitability(spot_price);
         push_profitability(&prof, &mut self.profitability);
     }

crates/brk_computer/src/distribution/cohorts/utxo/receive.rs

@@ -1,3 +1,4 @@
+use brk_cohort::EntryPrice;
 use brk_types::{Cents, CostBasisSnapshot, Height, Timestamp};
 use vecdb::Rw;
 
@@ -12,6 +13,7 @@ impl UTXOCohorts<Rw> {
     /// - The "under_1h" age cohort (all new UTXOs start at 0 hours old)
     /// - The appropriate epoch cohort based on block height
     /// - The appropriate class cohort based on block timestamp
+    /// - The immutable entry valuation cohort based on creation price versus anchor
     /// - The appropriate output type cohort (P2PKH, P2SH, etc.)
     /// - The appropriate amount range cohort based on value
     pub(crate) fn receive(
@@ -20,13 +22,14 @@ impl UTXOCohorts<Rw> {
         height: Height,
         timestamp: Timestamp,
         price: Cents,
+        entry: EntryPrice,
     ) {
         let supply_state = received.spendable_supply;
 
-        // Pre-compute snapshot once for the 3 cohorts sharing the same supply_state
+        // Pre-compute snapshot once for cohorts sharing the block-level supply_state
         let snapshot = CostBasisSnapshot::from_utxo(price, &supply_state);
 
-        // New UTXOs go into under_1h, current epoch, and current class
+        // New UTXOs go into under_1h plus immutable creation cohorts
         self.age_range
             .under_1h
             .state
@@ -45,6 +48,12 @@ impl UTXOCohorts<Rw> {
                 .unwrap()
                 .receive_utxo_snapshot(&supply_state, &snapshot);
         }
+        self.entry
+            .get_mut(entry)
+            .state
+            .as_mut()
+            .unwrap()
+            .receive_utxo_snapshot(&supply_state, &snapshot);
 
         // Update output type cohorts (skip types with no outputs this block)
         self.type_.iter_typed_mut().for_each(|(output_type, vecs)| {

crates/brk_computer/src/distribution/cohorts/utxo/send.rs

@@ -49,7 +49,7 @@ impl UTXOCohorts<Rw> {
             // This is the max price between receive and send heights
             let peak_price = price_range_max.max_between(receive_height, send_height);
 
-            // Pre-compute once for age_range, epoch, year (all share sent.spendable_supply)
+            // Pre-compute once for cohorts sharing the sent supply.
             if let Some(pre) = SendPrecomputed::new(
                 &sent.spendable_supply,
                 current_price,
@@ -75,6 +75,12 @@ impl UTXOCohorts<Rw> {
                         .unwrap()
                         .send_utxo_precomputed(&sent.spendable_supply, &pre);
                 }
+                self.entry
+                    .get_mut(block_state.entry)
+                    .state
+                    .as_mut()
+                    .unwrap()
+                    .send_utxo_precomputed(&sent.spendable_supply, &pre);
             } else if sent.spendable_supply.utxo_count > 0 {
                 // Zero-value UTXOs: just subtract supply
                 self.age_range.get_mut(age).state.as_mut().unwrap().supply -=
@@ -85,6 +91,12 @@ impl UTXOCohorts<Rw> {
                 if let Some(v) = self.class.mut_vec_from_timestamp(block_state.timestamp) {
                     v.state.as_mut().unwrap().supply -= &sent.spendable_supply;
                 }
+                self.entry
+                    .get_mut(block_state.entry)
+                    .state
+                    .as_mut()
+                    .unwrap()
+                    .supply -= &sent.spendable_supply;
             }
 
             // Update output type cohorts (skip zero-supply entries)

crates/brk_computer/src/distribution/cohorts/utxo/vecs/core.rs

@@ -6,7 +6,7 @@ use vecdb::{Exit, ReadableVec};
 
 use crate::{
     distribution::{cohorts::traits::DynCohortVecs, metrics::CoreCohortMetrics},
-    prices,
+    price,
 };
 
 use super::UTXOCohortVecs;
@@ -56,7 +56,7 @@ impl DynCohortVecs for UTXOCohortVecs<CoreCohortMetrics> {
 
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/cohorts/utxo/vecs/minimal.rs

@@ -6,7 +6,7 @@ use vecdb::{Exit, ReadableVec};
 
 use crate::{
     distribution::{cohorts::traits::DynCohortVecs, metrics::MinimalCohortMetrics},
-    prices,
+    price,
 };
 
 use super::UTXOCohortVecs;
@@ -49,7 +49,7 @@ impl DynCohortVecs for UTXOCohortVecs<MinimalCohortMetrics> {
 
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/cohorts/utxo/vecs/mod.rs

@@ -55,7 +55,7 @@ use crate::{
         metrics::{CohortMetricsBase, CohortMetricsState},
         state::UTXOCohortState,
     },
-    prices,
+    price,
 };
 
 #[derive(Traversable)]
@@ -186,7 +186,7 @@ impl<M: CohortMetricsBase + Traversable> DynCohortVecs for UTXOCohortVecs<M> {
 
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/cohorts/utxo/vecs/type.rs

@@ -5,7 +5,7 @@ use brk_types::{Cents, Height, Version};
 use vecdb::{Exit, ReadableVec};
 
 use crate::{
-    distribution::cohorts::traits::DynCohortVecs, distribution::metrics::TypeCohortMetrics, prices,
+    distribution::cohorts::traits::DynCohortVecs, distribution::metrics::TypeCohortMetrics, price,
 };
 
 use super::UTXOCohortVecs;
@@ -55,7 +55,7 @@ impl DynCohortVecs for UTXOCohortVecs<TypeCohortMetrics> {
 
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/compute/block_loop.rs

@@ -1,4 +1,4 @@
-use brk_cohort::ByAddrType;
+use brk_cohort::{ByAddrType, EntryPrice};
 use brk_error::Result;
 use brk_indexer::Indexer;
 use brk_types::{
@@ -46,6 +46,7 @@ pub(crate) fn process_blocks(
     last_height: Height,
     chain_state: &mut Vec<BlockState>,
     tx_index_to_height: &mut RangeMap<TxIndex, Height>,
+    mut entry_anchor: Cents,
     cached_prices: &[Cents],
     cached_timestamps: &[Timestamp],
     cached_price_range_max: &PriceRangeMax,
@@ -370,9 +371,14 @@ pub(crate) fn process_blocks(
                 .iterate(Sats::FIFTY_BTC, OutputType::P2PK65);
         }
 
+        let entry = EntryPrice::from_is_discount(
+            entry_anchor == Cents::ZERO || block_price <= entry_anchor,
+        );
+
         // Push current block state before processing cohort updates
         chain_state.push(BlockState {
             supply: transacted.spendable_supply,
+            entry,
             price: block_price,
             timestamp,
         });
@@ -411,7 +417,7 @@ pub(crate) fn process_blocks(
             || {
                 // UTXO cohorts receive/send
                 vecs.utxo_cohorts
-                    .receive(transacted, height, timestamp, block_price);
+                    .receive(transacted, height, timestamp, block_price, entry);
                 if let Some(min_h) =
                     vecs.utxo_cohorts
                         .send(height_to_sent, chain_state, ctx.price_range_max)
@@ -460,7 +466,7 @@ pub(crate) fn process_blocks(
         let is_last_of_day = is_last_of_day[offset];
         let date_opt = is_last_of_day.then(|| Date::from(timestamp));
 
-        push_cohort_states(
+        entry_anchor = push_cohort_states(
             &mut vecs.utxo_cohorts,
             &mut vecs.addr_cohorts,
             height,
@@ -527,7 +533,7 @@ fn push_cohort_states(
     addr_cohorts: &mut AddrCohorts,
     height: Height,
     height_price: Cents,
-) {
+) -> Cents {
     // Phase 1: push + unrealized (no reset yet, states still needed for aggregation)
     rayon::join(
         || {
@@ -545,7 +551,7 @@ fn push_cohort_states(
     );
 
     // Phase 2: aggregate age_range states → push to overlapping cohorts
-    utxo_cohorts.push_overlapping(height_price);
+    let all_capitalized_price = utxo_cohorts.push_overlapping(height_price);
 
     // Phase 3: reset per-block values
     utxo_cohorts
@@ -554,4 +560,6 @@ fn push_cohort_states(
     addr_cohorts
         .iter_separate_mut()
         .for_each(|v| v.reset_single_iteration_values());
+
+    all_capitalized_price
 }

crates/brk_computer/src/distribution/compute/recover.rs

@@ -24,51 +24,60 @@ pub struct RecoveredState {
 /// Returns Height::ZERO if any validation fails (triggers fresh start).
 pub(crate) fn recover_state(
     height: Height,
-    chain_state_rollback: vecdb::Result<Stamp>,
+    chain_state_rollback: Option<vecdb::Result<Stamp>>,
     any_addr_indexes: &mut AnyAddrIndexesVecs,
     addrs_data: &mut AddrsDataVecs,
     utxo_cohorts: &mut UTXOCohorts,
     addr_cohorts: &mut AddrCohorts,
 ) -> Result<RecoveredState> {
-    let stamp = Stamp::from(height);
+    // `None`: clean resume, already at the checkpoint, nothing to undo.
+    // `Some`: reorg, undo state past the resume point.
+    let consistent_height = match chain_state_rollback {
+        None => height,
+        Some(chain_state_rollback) => {
+            let stamp = Stamp::from(height);
 
-    // Rollback address state vectors
-    let addr_indexes_rollback = any_addr_indexes.rollback_before(stamp);
-    let addr_data_rollback = addrs_data.rollback_before(stamp);
+            // Rollback address state vectors
+            let addr_indexes_rollback = any_addr_indexes.rollback_before(stamp);
+            let addr_data_rollback = addrs_data.rollback_before(stamp);
 
-    // Verify rollback consistency - all must agree on the same height
-    let consistent_height = rollback_states(
-        chain_state_rollback,
-        addr_indexes_rollback,
-        addr_data_rollback,
-    );
+            // Verify rollback consistency - all must agree on the same height
+            let consistent_height = rollback_states(
+                chain_state_rollback,
+                addr_indexes_rollback,
+                addr_data_rollback,
+            );
 
-    // If rollbacks are inconsistent, start fresh
-    if consistent_height.is_zero() {
-        warn!("Rollback consistency check failed: inconsistent heights");
-        return Ok(RecoveredState {
-            starting_height: Height::ZERO,
-        });
-    }
+            // If rollbacks are inconsistent, start fresh
+            if consistent_height.is_zero() {
+                warn!("Rollback consistency check failed: inconsistent heights");
+                return Ok(RecoveredState {
+                    starting_height: Height::ZERO,
+                });
+            }
 
-    // Rollback can land at an earlier height (multi-block change file), which is fine.
-    // But if it lands AHEAD of target, that means rollback failed (missing change files).
-    if consistent_height > height {
-        warn!(
-            "Rollback failed: still at {} but target was {}, falling back to fresh start",
-            consistent_height, height
-        );
-        return Ok(RecoveredState {
-            starting_height: Height::ZERO,
-        });
-    }
+            // Rollback can land at an earlier height (multi-block change file), which is fine.
+            // But if it lands AHEAD of target, that means rollback failed (missing change files).
+            if consistent_height > height {
+                warn!(
+                    "Rollback failed: still at {} but target was {}, falling back to fresh start",
+                    consistent_height, height
+                );
+                return Ok(RecoveredState {
+                    starting_height: Height::ZERO,
+                });
+            }
 
-    if consistent_height != height {
-        debug!(
-            "Rollback landed at {} instead of {}, will resume from there",
-            consistent_height, height
-        );
-    }
+            if consistent_height != height {
+                debug!(
+                    "Rollback landed at {} instead of {}, will resume from there",
+                    consistent_height, height
+                );
+            }
+
+            consistent_height
+        }
+    };
 
     // Import UTXO cohort states - all must succeed
     debug!(

crates/brk_computer/src/distribution/metrics/activity/core.rs

@@ -11,7 +11,7 @@ use crate::{
         state::{CohortState, CostBasisOps, RealizedOps},
     },
     internal::{PerBlockCumulativeRolling, ValuePerBlockCumulativeRolling},
-    prices,
+    price,
 };
 
 use super::ActivityMinimal;
@@ -98,7 +98,7 @@ impl ActivityCore {
 
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/activity/full.rs

@@ -12,7 +12,7 @@ use crate::{
         metrics::ImportConfig,
         state::{CohortState, CostBasisOps, RealizedOps},
     },
-    prices,
+    price,
 };
 
 use super::ActivityCore;
@@ -89,7 +89,7 @@ impl ActivityFull {
 
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/activity/minimal.rs

@@ -10,7 +10,7 @@ use crate::{
         state::{CohortState, CostBasisOps, RealizedOps},
     },
     internal::ValuePerBlockCumulativeRolling,
-    prices,
+    price,
 };
 
 #[derive(Traversable)]
@@ -63,7 +63,7 @@ impl ActivityMinimal {
 
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/activity/mod.rs

@@ -13,7 +13,7 @@ use vecdb::Exit;
 
 use crate::{
     distribution::state::{CohortState, CostBasisOps, RealizedOps},
-    prices,
+    price,
 };
 
 pub trait ActivityLike: Send + Sync {
@@ -30,7 +30,7 @@ pub trait ActivityLike: Send + Sync {
     ) -> Result<()>;
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()>;
@@ -62,7 +62,7 @@ impl ActivityLike for ActivityCore {
     }
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -96,7 +96,7 @@ impl ActivityLike for ActivityFull {
     }
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/cohort/all.rs

@@ -11,7 +11,7 @@ use crate::{
         ActivityFull, AdjustedSopr, CohortMetricsBase, CostBasis, ImportConfig, OutputsBase,
         RealizedFull, RelativeForAll, SupplyCore, UnrealizedFull,
     },
-    prices,
+    price,
 };
 
 /// All-cohort metrics: extended realized + adjusted (as composable add-on),
@@ -100,7 +100,7 @@ impl AllCohortMetrics {
     pub(crate) fn compute_rest_part2(
         &mut self,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         height_to_market_cap: &impl ReadableVec<Height, Dollars>,
         under_1h_value_created: &impl ReadableVec<Height, Cents>,

crates/brk_computer/src/distribution/metrics/cohort/basic.rs

@@ -10,7 +10,7 @@ use crate::{
         ActivityCore, CohortMetricsBase, ImportConfig, OutputsBase, RealizedCore, SupplyCore,
         UnrealizedCore,
     },
-    prices,
+    price,
 };
 
 /// Basic cohort metrics: no extensions, used by age_range cohorts.
@@ -61,7 +61,7 @@ impl BasicCohortMetrics {
 
     pub(crate) fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         all_utxo_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/metrics/cohort/core.rs

@@ -10,7 +10,7 @@ use crate::{
         ActivityCore, CohortMetricsBase, ImportConfig, OutputsBase, RealizedCore, SupplyCore,
         UnrealizedCore,
     },
-    prices,
+    price,
 };
 
 #[derive(Traversable)]
@@ -102,7 +102,7 @@ impl CoreCohortMetrics {
 
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -122,7 +122,7 @@ impl CoreCohortMetrics {
 
     pub(crate) fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         all_utxo_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/metrics/cohort/extended.rs

@@ -12,7 +12,7 @@ use crate::{
         ActivityFull, CohortMetricsBase, CostBasis, ImportConfig, OutputsBase, RealizedFull,
         RelativeWithExtended, SupplyCore, UnrealizedFull,
     },
-    prices,
+    price,
 };
 
 /// Cohort metrics with extended realized + extended cost basis (no adjusted).
@@ -90,7 +90,7 @@ impl ExtendedCohortMetrics {
     pub(crate) fn compute_rest_part2(
         &mut self,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         height_to_market_cap: &impl ReadableVec<Height, Dollars>,
         all_supply_sats: &impl ReadableVec<Height, Sats>,

crates/brk_computer/src/distribution/metrics/cohort/extended_adjusted.rs

@@ -10,7 +10,7 @@ use crate::{
     distribution::metrics::{
         ActivityFull, AdjustedSopr, CohortMetricsBase, ImportConfig, RealizedFull, UnrealizedFull,
     },
-    prices,
+    price,
 };
 
 use super::ExtendedCohortMetrics;
@@ -62,7 +62,7 @@ impl ExtendedAdjustedCohortMetrics {
     pub(crate) fn compute_rest_part2(
         &mut self,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         height_to_market_cap: &impl ReadableVec<Height, Dollars>,
         under_1h_value_created: &impl ReadableVec<Height, Cents>,

crates/brk_computer/src/distribution/metrics/cohort/minimal.rs

@@ -9,7 +9,7 @@ use crate::{
     distribution::metrics::{
         ActivityMinimal, ImportConfig, OutputsBase, RealizedMinimal, SupplyBase, UnrealizedMinimal,
     },
-    prices,
+    price,
 };
 
 /// MinimalCohortMetrics: supply, outputs, realized cap/price/mvrv/profit/loss + value_created/destroyed.
@@ -97,7 +97,7 @@ impl MinimalCohortMetrics {
 
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -111,7 +111,7 @@ impl MinimalCohortMetrics {
 
     pub(crate) fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         all_utxo_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/metrics/cohort/type.rs

@@ -9,7 +9,7 @@ use crate::{
     distribution::metrics::{
         ActivityMinimal, ImportConfig, OutputsBase, RealizedMinimal, SupplyCore, UnrealizedBasic,
     },
-    prices,
+    price,
 };
 
 /// TypeCohortMetrics: supply(core), outputs(base), realized(minimal), unrealized(basic).
@@ -59,7 +59,7 @@ impl TypeCohortMetrics {
 
     pub(crate) fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -73,7 +73,7 @@ impl TypeCohortMetrics {
 
     pub(crate) fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         all_utxo_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/metrics/mod.rs

@@ -149,7 +149,7 @@ use crate::{
         CohortState, CoreRealizedState, CostBasisData, CostBasisOps, CostBasisRaw,
         MinimalRealizedState, RealizedOps, RealizedState, WithCapital, WithoutCapital,
     },
-    prices,
+    price,
 };
 
 pub trait CohortMetricsState {
@@ -270,7 +270,7 @@ pub trait CohortMetricsBase:
     /// First phase of computed metrics (indexes from height).
     fn compute_rest_part1(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/profitability.rs

@@ -10,7 +10,7 @@ use crate::{
     internal::{
         PerBlock, RatioPerBlock, ValuePerBlock, ValuePerBlockWithDeltas, WindowStartVec, Windows,
     },
-    prices,
+    price,
 };
 
 #[derive(Traversable)]
@@ -115,7 +115,7 @@ impl ProfitabilityBucket {
 
     pub(crate) fn compute(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         is_profit: bool,
         exit: &Exit,
@@ -176,7 +176,7 @@ impl ProfitabilityBucket {
 
     pub(crate) fn compute_from_ranges(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         is_profit: bool,
         sources: &[&ProfitabilityBucket],
@@ -293,7 +293,7 @@ impl ProfitabilityMetrics {
 
     pub(crate) fn compute(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/realized/core.rs

@@ -16,7 +16,7 @@ use crate::{
         FiatPerBlockCumulativeWithSumsAndDeltas, LazyPerBlock, NegCentsUnsignedToDollars,
         PerBlockCumulativeRolling, RatioCents64, RollingWindow24hPerBlock, Windows,
     },
-    prices,
+    price,
 };
 
 use crate::distribution::metrics::ImportConfig;
@@ -166,7 +166,7 @@ impl RealizedCore {
 
     pub(crate) fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         height_to_supply: &impl ReadableVec<Height, Bitcoin>,
         transfer_volume_sum_24h_cents: &impl ReadableVec<Height, Cents>,

crates/brk_computer/src/distribution/metrics/realized/full.rs

@@ -18,7 +18,7 @@ use crate::{
         RatioPerBlockStdDevBands, RatioSma, RollingWindows, RollingWindowsFrom1w,
         ValuePerBlockCumulativeRolling,
     },
-    prices,
+    price,
 };
 
 use crate::distribution::metrics::ImportConfig;
@@ -206,7 +206,7 @@ impl RealizedFull {
     }
 
     #[inline(always)]
-    pub(crate) fn push_accum(&mut self, accum: &RealizedFullAccum) {
+    pub(crate) fn push_accum(&mut self, accum: &RealizedFullAccum) -> Cents {
         self.cap_raw.push(accum.cap_raw);
         self.capitalized.cap_raw.push(accum.capitalized_cap_raw);
 
@@ -221,6 +221,8 @@ impl RealizedFull {
         self.capitalized.price.cents.height.push(capitalized_price);
 
         self.peak_regret.value.block.cents.push(accum.peak_regret());
+
+        capitalized_price
     }
 
     pub(crate) fn compute_rest_part1(
@@ -240,7 +242,7 @@ impl RealizedFull {
     pub(crate) fn compute_rest_part2(
         &mut self,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         height_to_supply: &impl ReadableVec<Height, Bitcoin>,
         height_to_market_cap: &impl ReadableVec<Height, Dollars>,

crates/brk_computer/src/distribution/metrics/realized/minimal.rs

@@ -13,7 +13,7 @@ use crate::{
         FiatPerBlockCumulativeWithSums, FiatPerBlockWithDeltas, Identity, LazyPerBlock,
         PriceWithRatioPerBlock,
     },
-    prices,
+    price,
 };
 
 use crate::distribution::metrics::ImportConfig;
@@ -104,7 +104,7 @@ impl RealizedMinimal {
 
     pub(crate) fn compute_rest_part2(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         height_to_supply: &impl ReadableVec<Height, Bitcoin>,
         exit: &Exit,

crates/brk_computer/src/distribution/metrics/supply/avg_amount.rs

@@ -3,7 +3,7 @@ use brk_traversable::Traversable;
 use brk_types::{Height, Sats, StoredU64, Version};
 use vecdb::{AnyStoredVec, Database, Exit, ReadableVec, Rw, StorageMode, WritableVec};
 
-use crate::{indexes, internal::ValuePerBlock, prices};
+use crate::{indexes, internal::ValuePerBlock, price};
 
 /// Average amount held per UTXO and per funded address.
 ///
@@ -53,7 +53,7 @@ impl AvgAmountMetrics {
 
     pub(crate) fn compute(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         supply_sats: &impl ReadableVec<Height, Sats>,
         utxo_count: &impl ReadableVec<Height, StoredU64>,
         funded_addr_count: &impl ReadableVec<Height, StoredU64>,

crates/brk_computer/src/distribution/metrics/supply/base.rs

@@ -6,7 +6,7 @@ use vecdb::{AnyStoredVec, AnyVec, Exit, ReadableVec, Rw, StorageMode, WritableVe
 
 use crate::{
     distribution::state::{CohortState, CostBasisOps, RealizedOps},
-    prices,
+    price,
 };
 
 use crate::internal::{
@@ -64,7 +64,7 @@ impl SupplyBase {
 
     pub(crate) fn compute(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         max_from: Height,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/supply/core.rs

@@ -5,7 +5,7 @@ use brk_types::{Height, Version};
 use derive_more::{Deref, DerefMut};
 use vecdb::{AnyStoredVec, AnyVec, Exit, Rw, StorageMode, WritableVec};
 
-use crate::{distribution::state::UnrealizedState, prices};
+use crate::{distribution::state::UnrealizedState, price};
 
 use crate::internal::{
     HalveCents, HalveDollars, HalveSats, HalveSatsToBitcoin, LazyValuePerBlock, ValuePerBlock,
@@ -72,7 +72,7 @@ impl SupplyCore {
 
     pub(crate) fn compute(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         max_from: Height,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/distribution/metrics/unrealized/full.rs

@@ -7,7 +7,7 @@ use vecdb::{AnyStoredVec, AnyVec, BytesVec, Exit, ReadableVec, Rw, StorageMode,
 
 use crate::distribution::state::UnrealizedState;
 use crate::internal::{CentsSubtractToCentsSigned, FiatPerBlock};
-use crate::{distribution::metrics::ImportConfig, prices};
+use crate::{distribution::metrics::ImportConfig, price};
 
 use super::UnrealizedCore;
 
@@ -99,7 +99,7 @@ impl UnrealizedFull {
 
     pub(crate) fn compute_rest_all(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         supply_in_profit_sats: &(impl ReadableVec<Height, Sats> + Sync),
         supply_in_loss_sats: &(impl ReadableVec<Height, Sats> + Sync),

crates/brk_computer/src/distribution/metrics/unrealized/mod.rs

@@ -13,7 +13,7 @@ use brk_indexer::Lengths;
 use brk_types::{Height, Sats};
 use vecdb::{Exit, ReadableVec};
 
-use crate::{distribution::state::UnrealizedState, prices};
+use crate::{distribution::state::UnrealizedState, price};
 
 pub trait UnrealizedLike: Send + Sync {
     fn as_core(&self) -> &UnrealizedCore;
@@ -22,7 +22,7 @@ pub trait UnrealizedLike: Send + Sync {
     fn push_state(&mut self, state: &UnrealizedState);
     fn compute_rest(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         supply_in_profit_sats: &(impl ReadableVec<Height, Sats> + Sync),
         supply_in_loss_sats: &(impl ReadableVec<Height, Sats> + Sync),
@@ -46,7 +46,7 @@ impl UnrealizedLike for UnrealizedCore {
     }
     fn compute_rest(
         &mut self,
-        _prices: &prices::Vecs,
+        _prices: &price::Vecs,
         starting_lengths: &Lengths,
         _supply_in_profit_sats: &(impl ReadableVec<Height, Sats> + Sync),
         _supply_in_loss_sats: &(impl ReadableVec<Height, Sats> + Sync),
@@ -72,7 +72,7 @@ impl UnrealizedLike for UnrealizedFull {
     }
     fn compute_rest(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         supply_in_profit_sats: &(impl ReadableVec<Height, Sats> + Sync),
         supply_in_loss_sats: &(impl ReadableVec<Height, Sats> + Sync),

crates/brk_computer/src/distribution/state/block.rs

@@ -1,5 +1,6 @@
 use std::ops::{Add, AddAssign, SubAssign};
 
+use brk_cohort::EntryPrice;
 use brk_types::{Cents, SupplyState, Timestamp};
 use serde::Serialize;
 
@@ -8,6 +9,8 @@ pub struct BlockState {
     #[serde(flatten)]
     pub supply: SupplyState,
     #[serde(skip)]
+    pub entry: EntryPrice,
+    #[serde(skip)]
     pub price: Cents,
     #[serde(skip)]
     pub timestamp: Timestamp,

crates/brk_computer/src/distribution/vecs.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use brk_cohort::{ByAddrType, Filter};
+use brk_cohort::{ByAddrType, EntryPrice, Filter};
 use brk_error::Result;
 use brk_indexer::Indexer;
 use brk_traversable::Traversable;
@@ -29,7 +29,7 @@ use crate::{
         PerBlockCumulativeRolling, WindowStartVec, Windows, WithAddrTypes,
         db_utils::{finalize_db, open_db},
     },
-    outputs, prices, transactions,
+    outputs, price, transactions,
 };
 
 use super::{
@@ -41,7 +41,7 @@ use super::{
     metrics::AvgAmountMetrics,
 };
 
-const VERSION: Version = Version::new(24);
+const VERSION: Version = Version::new(24 + brk_oracle::VERSION);
 
 #[derive(Traversable)]
 pub struct AddrMetricsVecs<M: StorageMode = Rw> {
@@ -316,7 +316,7 @@ impl Vecs {
         outputs: &outputs::Vecs,
         transactions: &transactions::Vecs,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         self.db.sync_bg_tasks()?;
@@ -341,12 +341,13 @@ impl Vecs {
         // Try to resume from checkpoint, fall back to fresh start if needed
         let recovered_height = match start_mode {
             StartMode::Resume(height) => {
-                let stamp = Stamp::from(height);
+                // Roll back only on a reorg. A clean resume has nothing to undo, and an
+                // interrupted run wrote no rollback metadata (periodic flushes use
+                // with_changes=false; only the final write creates the `changes/` dir),
+                // so `rollback_before` would fail with `NotFound`.
+                let chain_state_rollback = (height < current_height)
+                    .then(|| self.supply_state.rollback_before(Stamp::from(height)));
 
-                // Rollback BytesVec state and capture results for validation
-                let chain_state_rollback = self.supply_state.rollback_before(stamp);
-
-                // Validate all rollbacks and imports are consistent
                 let recovered = recover_state(
                     height,
                     chain_state_rollback,
@@ -435,13 +436,34 @@ impl Vecs {
             let end = usize::from(recovered_height);
             debug!("building supply_state vec for {} heights", recovered_height);
             let supply_state_data: Vec<_> = self.supply_state.collect_range_at(0, end);
+            let capitalized_price_data: Vec<_> = self
+                .utxo_cohorts
+                .all
+                .metrics
+                .realized
+                .capitalized
+                .price
+                .cents
+                .height
+                .collect_range_at(0, end);
+
+            let mut entry_anchor = Cents::ZERO;
             chain_state = supply_state_data
                 .into_iter()
                 .enumerate()
-                .map(|(h, supply)| BlockState {
-                    supply,
-                    price: self.caches.prices[h],
-                    timestamp: self.caches.timestamps[h],
+                .map(|(h, supply)| {
+                    let price = self.caches.prices[h];
+                    let entry = EntryPrice::from_is_discount(
+                        entry_anchor == Cents::ZERO || price <= entry_anchor,
+                    );
+                    entry_anchor = capitalized_price_data[h];
+
+                    BlockState {
+                        supply,
+                        entry,
+                        price,
+                        timestamp: self.caches.timestamps[h],
+                    }
                 })
                 .collect();
             debug!("chain_state rebuilt");
@@ -473,6 +495,20 @@ impl Vecs {
             let prices = std::mem::take(&mut self.caches.prices);
             let timestamps = std::mem::take(&mut self.caches.timestamps);
             let price_range_max = std::mem::take(&mut self.caches.price_range_max);
+            let entry_anchor = starting_height
+                .decremented()
+                .and_then(|height| {
+                    self.utxo_cohorts
+                        .all
+                        .metrics
+                        .realized
+                        .capitalized
+                        .price
+                        .cents
+                        .height
+                        .collect_one(height)
+                })
+                .unwrap_or(Cents::ZERO);
 
             process_blocks(
                 self,
@@ -485,6 +521,7 @@ impl Vecs {
                 last_height,
                 &mut chain_state,
                 &mut tx_index_to_height,
+                entry_anchor,
                 &prices,
                 &timestamps,
                 &price_range_max,

crates/brk_computer/src/indicators/rarity_meter/mod.rs

@@ -6,7 +6,7 @@ use brk_traversable::Traversable;
 use brk_types::Version;
 use vecdb::{Database, Exit, Rw, StorageMode};
 
-use crate::{distribution, indexes, prices};
+use crate::{distribution, indexes, price};
 
 pub use inner::RarityMeterInner;
 
@@ -37,7 +37,7 @@ impl RarityMeter {
         &mut self,
         indexer: &Indexer,
         distribution: &distribution::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         let realized = &distribution.utxo_cohorts.all.metrics.realized;

crates/brk_computer/src/internal/per_block/ratio/price_extended.rs

@@ -6,7 +6,7 @@ use derive_more::{Deref, DerefMut};
 use vecdb::{Database, EagerVec, Exit, PcoVec, ReadableVec, Rw, StorageMode};
 
 use crate::internal::{LazyPerBlock, PerBlock, Price};
-use crate::{indexes, prices};
+use crate::{indexes, price};
 
 use super::{RatioPerBlock, RatioPerBlockPercentiles};
 
@@ -63,7 +63,7 @@ impl PriceWithRatioPerBlock {
     /// Compute price via closure (in cents), then compute ratio.
     pub(crate) fn compute_all<F>(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
         mut compute_price: F,
@@ -101,7 +101,7 @@ impl PriceWithRatioExtendedPerBlock {
     /// Compute ratio and percentiles from already-computed price cents.
     pub(crate) fn compute_rest(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
@@ -120,7 +120,7 @@ impl PriceWithRatioExtendedPerBlock {
     /// Compute price via closure (in cents), then compute ratio and percentiles.
     pub(crate) fn compute_all<F>(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         starting_lengths: &Lengths,
         exit: &Exit,
         mut compute_price: F,

crates/brk_computer/src/internal/per_block/value/base.rs

@@ -10,7 +10,7 @@ use crate::{
         CentsUnsignedToDollars, LazyPerBlock, NumericValue, PerBlock, SatsSignedToBitcoin,
         SatsToBitcoin, SatsToCents,
     },
-    prices,
+    price,
 };
 
 /// Trait that associates a sats type with its transform to Bitcoin.
@@ -69,7 +69,7 @@ impl ValuePerBlock {
 
     pub(crate) fn compute(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         max_from: Height,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/internal/per_block/value/block.rs

@@ -8,7 +8,7 @@ use vecdb::{
 
 use crate::{
     internal::{CentsUnsignedToDollars, SatsToBitcoin, SatsToCents},
-    prices,
+    price,
 };
 
 /// Raw per-block amount data: sats + cents (stored), btc + usd (lazy), no resolutions.
@@ -44,7 +44,7 @@ impl ValueBlock {
     pub(crate) fn compute_cents(
         &mut self,
         max_from: Height,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         self.cents.compute_binary::<Sats, Cents, SatsToCents>(

crates/brk_computer/src/internal/per_block/value/cumulative.rs

@@ -6,7 +6,7 @@ use vecdb::{Database, EagerVec, Exit, PcoVec, Rw, StorageMode};
 use crate::{
     indexes,
     internal::{ValueBlock, ValuePerBlock},
-    prices,
+    price,
 };
 
 #[derive(Traversable)]
@@ -39,7 +39,7 @@ impl ValuePerBlockCumulative {
 
     pub(crate) fn compute(
         &mut self,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         max_from: Height,
         exit: &Exit,
     ) -> Result<()> {
@@ -61,7 +61,7 @@ impl ValuePerBlockCumulative {
     pub(crate) fn compute_with(
         &mut self,
         max_from: Height,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
         compute_sats: impl FnOnce(&mut EagerVec<PcoVec<Height, Sats>>) -> Result<()>,
     ) -> Result<()> {

crates/brk_computer/src/internal/per_block/value/cumulative_rolling.rs

@@ -10,7 +10,7 @@ use crate::{
         LazyRollingAvgsAmountFromHeight, LazyRollingSumsAmountFromHeight, ValuePerBlockCumulative,
         WindowStartVec, Windows,
     },
-    prices,
+    price,
 };
 
 #[derive(Deref, DerefMut, Traversable)]
@@ -63,7 +63,7 @@ impl ValuePerBlockCumulativeRolling {
     pub(crate) fn compute(
         &mut self,
         max_from: Height,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
         compute_sats: impl FnOnce(&mut EagerVec<PcoVec<Height, Sats>>) -> Result<()>,
     ) -> Result<()> {
@@ -74,7 +74,7 @@ impl ValuePerBlockCumulativeRolling {
     pub(crate) fn compute_rest(
         &mut self,
         max_from: Height,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         self.inner.compute(prices, max_from, exit)

crates/brk_computer/src/internal/per_block/value/full.rs

@@ -10,7 +10,7 @@ use crate::{
         RollingDistributionValuePerBlock, ValuePerBlockCumulativeRolling, WindowStartVec,
         WindowStarts, Windows,
     },
-    prices,
+    price,
 };
 
 #[derive(Deref, DerefMut, Traversable)]
@@ -49,7 +49,7 @@ impl ValuePerBlockFull {
         &mut self,
         max_from: Height,
         windows: &WindowStarts<'_>,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
         compute_sats: impl FnOnce(&mut EagerVec<PcoVec<Height, Sats>>) -> Result<()>,
     ) -> Result<()> {

crates/brk_computer/src/internal/with_addr_types.rs

@@ -11,7 +11,7 @@ use rayon::prelude::*;
 use schemars::JsonSchema;
 use vecdb::{AnyStoredVec, AnyVec, Database, EagerVec, Exit, PcoVec, WritableVec};
 
-use crate::{indexes, prices};
+use crate::{indexes, price};
 
 use super::{
     BpsType, NumericValue, PerBlock, PerBlockCumulativeRolling, PercentPerBlock, ValuePerBlock,
@@ -229,7 +229,7 @@ impl WithAddrTypes<ValuePerBlock> {
     pub(crate) fn compute_rest(
         &mut self,
         max_from: Height,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         self.all.compute(prices, max_from, exit)?;

crates/brk_computer/src/investing/compute.rs

@@ -4,7 +4,7 @@ use brk_types::{BasisPointsSigned32, Bitcoin, Cents, Date, Day1, Dollars, Sats};
 use vecdb::{AnyVec, Exit, ReadableOptionVec, ReadableVec, VecIndex};
 
 use super::{ByDcaPeriod, Vecs};
-use crate::{blocks, indexes, internal::RatioDiffCentsBps32, market, prices};
+use crate::{blocks, indexes, internal::RatioDiffCentsBps32, market, price};
 
 const DCA_AMOUNT: Dollars = Dollars::mint(100.0);
 
@@ -13,7 +13,7 @@ impl Vecs {
         &mut self,
         indexer: &Indexer,
         indexes: &indexes::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         blocks: &blocks::Vecs,
         lookback: &market::lookback::Vecs,
         exit: &Exit,

crates/brk_computer/src/lib.rs

@@ -22,7 +22,7 @@ mod market;
 mod mining;
 mod outputs;
 mod pools;
-pub mod prices;
+pub mod price;
 mod supply;
 mod transactions;
 
@@ -38,7 +38,7 @@ pub struct Computer<M: StorageMode = Rw> {
     pub investing: Box<investing::Vecs<M>>,
     pub market: Box<market::Vecs<M>>,
     pub pools: Box<pools::Vecs<M>>,
-    pub prices: Box<prices::Vecs<M>>,
+    pub price: Box<price::Vecs<M>>,
     #[traversable(flatten)]
     pub distribution: Box<distribution::Vecs<M>>,
     pub supply: Box<supply::Vecs<M>>,
@@ -66,14 +66,14 @@ impl Computer {
             )?))
         })?;
 
-        let (constants, prices) = timed("Imported prices/constants", || -> Result<_> {
+        let (constants, price) = timed("Imported price/constants", || -> Result<_> {
             let constants = Box::new(constants::Vecs::new(VERSION, &indexes));
-            let prices = Box::new(prices::Vecs::forced_import(
+            let price = Box::new(price::Vecs::forced_import(
                 &computed_path,
                 VERSION,
                 &indexes,
             )?);
-            Ok((constants, prices))
+            Ok((constants, price))
         })?;
 
         let blocks = timed("Imported blocks", || -> Result<_> {
@@ -223,7 +223,7 @@ impl Computer {
             cointime,
             indexes,
             inputs,
-            prices,
+            price,
             outputs,
         };
 
@@ -244,7 +244,7 @@ impl Computer {
             investing::DB_NAME,
             market::DB_NAME,
             pools::DB_NAME,
-            prices::DB_NAME,
+            price::DB_NAME,
             distribution::DB_NAME,
             supply::DB_NAME,
             inputs::DB_NAME,
@@ -297,8 +297,8 @@ impl Computer {
                     })
                 },
                 || {
-                    timed("Computed prices", || {
-                        self.prices.compute(indexer, &self.indexes, exit)
+                    timed("Computed price", || {
+                        self.price.compute(indexer, &self.indexes, exit)
                     })
                 },
             );
@@ -310,7 +310,7 @@ impl Computer {
             let market = scope.spawn(|| {
                 timed("Computed market", || {
                     self.market
-                        .compute(indexer, &self.prices, &self.indexes, &self.blocks, exit)
+                        .compute(indexer, &self.price, &self.indexes, &self.blocks, exit)
                 })
             });
 
@@ -321,7 +321,7 @@ impl Computer {
                         &self.indexes,
                         &self.blocks,
                         &self.inputs,
-                        &self.prices,
+                        &self.price,
                         exit,
                     )
                 })?;
@@ -331,7 +331,7 @@ impl Computer {
                         &self.indexes,
                         &self.blocks,
                         &self.transactions,
-                        &self.prices,
+                        &self.price,
                         exit,
                     )
                 })
@@ -343,7 +343,7 @@ impl Computer {
                     &self.indexes,
                     &self.inputs,
                     &self.blocks,
-                    &self.prices,
+                    &self.price,
                     exit,
                 )
             })?;
@@ -360,7 +360,7 @@ impl Computer {
                         indexer,
                         &self.indexes,
                         &self.blocks,
-                        &self.prices,
+                        &self.price,
                         &self.mining,
                         exit,
                     )
@@ -372,7 +372,7 @@ impl Computer {
                     self.investing.compute(
                         indexer,
                         &self.indexes,
-                        &self.prices,
+                        &self.price,
                         &self.blocks,
                         &self.market.lookback,
                         exit,
@@ -388,7 +388,7 @@ impl Computer {
                     &self.outputs,
                     &self.transactions,
                     &self.blocks,
-                    &self.prices,
+                    &self.price,
                     exit,
                 )
             })?;
@@ -421,7 +421,7 @@ impl Computer {
                     &self.blocks,
                     &self.mining,
                     &self.transactions,
-                    &self.prices,
+                    &self.price,
                     &self.distribution,
                     exit,
                 )
@@ -430,7 +430,7 @@ impl Computer {
             timed("Computed cointime", || {
                 self.cointime.compute(
                     indexer,
-                    &self.prices,
+                    &self.price,
                     &self.blocks,
                     &self.mining,
                     &self.supply,
@@ -445,7 +445,7 @@ impl Computer {
 
         self.indicators
             .rarity_meter
-            .compute(indexer, &self.distribution, &self.prices, exit)?;
+            .compute(indexer, &self.distribution, &self.price, exit)?;
 
         info!("Total compute time: {:?}", compute_start.elapsed());
         Ok(())
@@ -498,7 +498,7 @@ impl_iter_named!(
     investing,
     market,
     pools,
-    prices,
+    price,
     distribution,
     supply,
     inputs,

crates/brk_computer/src/market/ath/compute.rs

@@ -4,13 +4,13 @@ use brk_types::{StoredF32, Timestamp};
 use vecdb::{Exit, ReadableVec, VecIndex};
 
 use super::Vecs;
-use crate::{indexes, prices};
+use crate::{indexes, price};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         indexes: &indexes::Vecs,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/market/compute.rs

@@ -2,7 +2,7 @@ use brk_error::Result;
 use brk_indexer::Indexer;
 use vecdb::Exit;
 
-use crate::{blocks, indexes, prices};
+use crate::{blocks, indexes, price};
 
 use super::Vecs;
 
@@ -10,7 +10,7 @@ impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
         exit: &Exit,

crates/brk_computer/src/market/lookback/compute.rs

@@ -3,14 +3,14 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, prices};
+use crate::{blocks, price};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         let starting_height = indexer.safe_lengths().height;

crates/brk_computer/src/market/moving_average/compute.rs

@@ -3,14 +3,14 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, prices};
+use crate::{blocks, price};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         let starting_lengths = indexer.safe_lengths();

crates/brk_computer/src/market/range/compute.rs

@@ -4,13 +4,13 @@ use brk_types::{BasisPoints16, StoredF32};
 use vecdb::{Exit, ReadableVec, VecIndex};
 
 use super::Vecs;
-use crate::{blocks, prices};
+use crate::{blocks, price};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         blocks: &blocks::Vecs,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/market/returns/compute.rs

@@ -5,14 +5,14 @@ use vecdb::Exit;
 
 use super::Vecs;
 use crate::{
-    blocks, internal::RatioDiffDollarsBps32, investing::ByDcaPeriod, market::lookback, prices,
+    blocks, internal::RatioDiffDollarsBps32, investing::ByDcaPeriod, market::lookback, price,
 };
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         blocks: &blocks::Vecs,
         lookback: &lookback::Vecs,
         exit: &Exit,

crates/brk_computer/src/market/technical/compute.rs

@@ -10,7 +10,7 @@ use super::{
 use crate::{
     blocks,
     internal::{RatioDollarsBp32, WindowsTo1m},
-    prices,
+    price,
 };
 
 impl Vecs {
@@ -19,7 +19,7 @@ impl Vecs {
         &mut self,
         indexer: &Indexer,
         returns: &returns::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         blocks: &blocks::Vecs,
         moving_average: &moving_average::Vecs,
         exit: &Exit,

crates/brk_computer/src/market/technical/macd.rs

@@ -3,14 +3,14 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::MacdChain;
-use crate::{blocks, prices};
+use crate::{blocks, price};
 
 #[allow(clippy::too_many_arguments)]
 pub(super) fn compute(
     chain: &mut MacdChain,
     indexer: &Indexer,
     blocks: &blocks::Vecs,
-    prices: &prices::Vecs,
+    prices: &price::Vecs,
     fast_days: usize,
     slow_days: usize,
     signal_days: usize,

crates/brk_computer/src/mining/compute.rs

@@ -3,7 +3,7 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, indexes, prices, transactions};
+use crate::{blocks, indexes, price, transactions};
 
 impl Vecs {
     #[allow(clippy::too_many_arguments)]
@@ -13,7 +13,7 @@ impl Vecs {
         indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
         transactions: &transactions::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         self.db.sync_bg_tasks()?;

crates/brk_computer/src/mining/rewards/compute.rs

@@ -7,7 +7,7 @@ use super::Vecs;
 use crate::{
     blocks, indexes,
     internal::{RatioDollarsBp32, RatioSatsBp16},
-    prices, transactions,
+    price, transactions,
 };
 
 impl Vecs {
@@ -18,7 +18,7 @@ impl Vecs {
         indexes: &indexes::Vecs,
         lookback: &blocks::LookbackVecs,
         transactions: &transactions::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         let starting_height = indexer.safe_lengths().height;

crates/brk_computer/src/outputs/compute.rs

@@ -3,7 +3,7 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, indexes, inputs, prices};
+use crate::{blocks, indexes, inputs, price};
 
 impl Vecs {
     #[allow(clippy::too_many_arguments)]
@@ -13,7 +13,7 @@ impl Vecs {
         indexes: &indexes::Vecs,
         inputs: &inputs::Vecs,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         self.db.sync_bg_tasks()?;

crates/brk_computer/src/outputs/value/compute.rs

@@ -4,13 +4,13 @@ use brk_types::{Height, OutputType, Sats, TxOutIndex};
 use vecdb::{AnyStoredVec, AnyVec, Exit, ReadableVec, VecIndex, WritableVec};
 
 use super::Vecs;
-use crate::prices;
+use crate::price;
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         let starting_lengths = indexer.safe_lengths();

crates/brk_computer/src/pools/major.rs

@@ -11,7 +11,7 @@ use crate::{
         MaskSats, PercentRollingWindows, RatioU64Bp16, ValuePerBlockCumulativeRolling,
         WindowStartVec, Windows,
     },
-    mining, prices,
+    mining, price,
 };
 
 use super::minor;
@@ -63,7 +63,7 @@ impl Vecs {
         indexer: &Indexer,
         pool: &impl ReadableVec<Height, PoolSlug>,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         mining: &mining::Vecs,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/pools/mod.rs

@@ -22,7 +22,7 @@ use crate::{
         WindowStartVec, Windows,
         db_utils::{finalize_db, open_db},
     },
-    mining, prices,
+    mining, price,
 };
 
 pub const DB_NAME: &str = "pools";
@@ -90,7 +90,7 @@ impl Vecs {
         indexer: &Indexer,
         indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         mining: &mining::Vecs,
         exit: &Exit,
     ) -> Result<()> {

crates/brk_computer/src/price/compute.rs

@@ -1,8 +1,10 @@
 use std::ops::Range;
 
-use brk_error::{Error, Result};
+use brk_error::Result;
 use brk_indexer::{Indexer, Lengths};
-use brk_oracle::{Config, NUM_BINS, Oracle, START_HEIGHT, bin_to_cents, cents_to_bin};
+use brk_oracle::{
+    bin_to_cents, cents_to_bin, Config, Oracle, PaymentFilter, START_HEIGHT_FAST, START_HEIGHT_SLOW,
+};
 use brk_types::{Cents, OutputType, Sats, TxIndex, TxOutIndex};
 use tracing::info;
 use vecdb::{AnyStoredVec, AnyVec, Exit, ReadableVec, StorageMode, VecIndex, WritableVec};
@@ -71,7 +73,7 @@ impl Vecs {
 
         let total_heights = indexer.vecs.blocks.timestamp.len();
 
-        if total_heights <= START_HEIGHT {
+        if total_heights <= START_HEIGHT_SLOW {
             return Ok(());
         }
 
@@ -83,17 +85,12 @@ impl Vecs {
             .inner
             .truncate_if_needed_at(truncate_to)?;
 
-        if self.spot.cents.height.len() < START_HEIGHT {
-            for line in brk_oracle::PRICES
-                .lines()
-                .skip(self.spot.cents.height.len())
-            {
-                if self.spot.cents.height.len() >= START_HEIGHT {
+        if self.spot.cents.height.len() < START_HEIGHT_SLOW {
+            for cents in brk_oracle::pre_oracle_prices_from(self.spot.cents.height.len()) {
+                if self.spot.cents.height.len() >= START_HEIGHT_SLOW {
                     break;
                 }
-                let dollars: f64 = line.parse().unwrap_or(0.0);
-                let cents = (dollars * 100.0).round() as u64;
-                self.spot.cents.height.inner.push(Cents::new(cents));
+                self.spot.cents.height.inner.push(cents);
             }
         }
 
@@ -101,8 +98,8 @@ impl Vecs {
             return Ok(());
         }
 
-        let config = Config::default();
         let committed = self.spot.cents.height.len();
+        let config = Config::for_height(committed);
         let prev_cents = self
             .spot
             .cents
@@ -110,9 +107,9 @@ impl Vecs {
             .collect_one_at(committed - 1)
             .unwrap();
         let seed_bin = cents_to_bin(prev_cents.inner() as f64);
-        let warmup = config.window_size.min(committed - START_HEIGHT);
+        let warmup = config.window_size.min(committed - START_HEIGHT_SLOW);
         let mut oracle = Oracle::from_checkpoint(seed_bin, config, |o| {
-            Self::feed_blocks(o, indexer, (committed - warmup)..committed);
+            Self::feed_blocks_for_warmup(o, indexer, (committed - warmup)..committed, None);
         });
 
         let num_new = total_heights - committed;
@@ -121,18 +118,48 @@ impl Vecs {
             committed, total_heights
         );
 
-        let ref_bins = Self::feed_blocks(&mut oracle, indexer, committed..total_heights);
+        // Slow cold-start EMA up to START_HEIGHT_FAST, then switch to the fast
+        // mature-market EMA. Steady-state runs start past START_HEIGHT_FAST and skip
+        // the slow segment entirely.
+        {
+            let mut processed = 0usize;
+            let mut push_ref_bin = |ref_bin| {
+                self.spot
+                    .cents
+                    .height
+                    .inner
+                    .push(Cents::new(bin_to_cents(ref_bin)));
 
-        for (i, ref_bin) in ref_bins.into_iter().enumerate() {
-            self.spot
-                .cents
-                .height
-                .inner
-                .push(Cents::new(bin_to_cents(ref_bin)));
+                processed += 1;
+                let progress = (processed * 100 / num_new) as u8;
+                if processed > 1 && progress > (((processed - 1) * 100 / num_new) as u8) {
+                    info!("Oracle price computation: {}%", progress);
+                }
+            };
 
-            let progress = ((i + 1) * 100 / num_new) as u8;
-            if i > 0 && progress > ((i * 100 / num_new) as u8) {
-                info!("Oracle price computation: {}%", progress);
+            if committed < START_HEIGHT_FAST {
+                let slow_end = START_HEIGHT_FAST.min(total_heights);
+                Self::feed_blocks_with(
+                    &mut oracle,
+                    indexer,
+                    committed..slow_end,
+                    None,
+                    |_, _, ref_bin| push_ref_bin(ref_bin),
+                );
+                if slow_end == START_HEIGHT_FAST {
+                    oracle.reconfigure(Config::default());
+                }
+            }
+
+            let fast_start = committed.max(START_HEIGHT_FAST);
+            if fast_start < total_heights {
+                Self::feed_blocks_with(
+                    &mut oracle,
+                    indexer,
+                    fast_start..total_heights,
+                    None,
+                    |_, _, ref_bin| push_ref_bin(ref_bin),
+                );
             }
         }
 
@@ -150,35 +177,44 @@ impl Vecs {
     }
 
     /// Feed a range of blocks from the indexer into an Oracle (skipping coinbase),
-    /// returning per-block ref_bin values. Uncapped: derives boundaries from
-    /// raw indexer vec lengths. Use during compute, when the indexer is
-    /// quiescent and `safe_lengths` is still pinned at the pre-pass value.
-    fn feed_blocks<M: StorageMode>(
+    /// returning per-block ref_bin values.
+    ///
+    /// Pass `cap = None` from compute paths, when the indexer is quiescent and
+    /// raw vec lengths are authoritative. Pass `cap = Some(&safe_lengths)` from
+    /// reader paths so concurrent writer pushes past the cap are invisible.
+    pub fn feed_blocks<IM: StorageMode>(
         oracle: &mut Oracle,
-        indexer: &Indexer<M>,
-        range: Range<usize>,
-    ) -> Vec<f64> {
-        Self::feed_blocks_inner(oracle, indexer, range, None)
-    }
-
-    /// Capped variant: derives boundaries from `cap` instead of raw vec
-    /// lengths, so concurrent writer pushes past `cap` are invisible.
-    /// Reader paths (live_oracle) use this with the current `safe_lengths`.
-    fn feed_blocks_capped<M: StorageMode>(
-        oracle: &mut Oracle,
-        indexer: &Indexer<M>,
-        range: Range<usize>,
-        cap: &Lengths,
-    ) -> Vec<f64> {
-        Self::feed_blocks_inner(oracle, indexer, range, Some(cap))
-    }
-
-    fn feed_blocks_inner<M: StorageMode>(
-        oracle: &mut Oracle,
-        indexer: &Indexer<M>,
+        indexer: &Indexer<IM>,
         range: Range<usize>,
         cap: Option<&Lengths>,
     ) -> Vec<f64> {
+        let mut ref_bins = Vec::with_capacity(range.len());
+        Self::feed_blocks_with(oracle, indexer, range, cap, |_, _, ref_bin| {
+            ref_bins.push(ref_bin);
+        });
+        ref_bins
+    }
+
+    /// Feed blocks into an Oracle when callers only need the warmed EMA/window state.
+    pub fn feed_blocks_for_warmup<IM: StorageMode>(
+        oracle: &mut Oracle,
+        indexer: &Indexer<IM>,
+        range: Range<usize>,
+        cap: Option<&Lengths>,
+    ) {
+        Self::feed_blocks_with(oracle, indexer, range, cap, |_, _, _| {});
+    }
+
+    /// Feed a range of blocks into an Oracle and call `on_block` after each
+    /// processed block. This lets callers observe derived state such as EMA
+    /// without duplicating the histogram extraction path.
+    pub fn feed_blocks_with<IM: StorageMode>(
+        oracle: &mut Oracle,
+        indexer: &Indexer<IM>,
+        range: Range<usize>,
+        cap: Option<&Lengths>,
+        mut on_block: impl FnMut(usize, &Oracle, f64),
+    ) {
         let (total_txs, total_outputs, height_len) = match cap {
             Some(c) => (
                 c.tx_index.to_usize(),
@@ -206,38 +242,38 @@ impl Vecs {
             .first_txout_index
             .collect_range_at(range.start, collect_end);
 
-        let mut ref_bins = Vec::with_capacity(range.len());
-
-        // Cursor avoids per-block PcoVec page decompression for
-        // the tx-indexed first_txout_index lookup.  The accessed
-        // tx_index values (first_tx_index + 1) are strictly increasing
-        // across blocks, so the cursor only advances forward.
+        // Cursor avoids per-block PcoVec page decompression for the
+        // tx-indexed first_txout_index lookup. Accessed tx_index values
+        // are strictly increasing across blocks, so it only advances forward.
         let mut txout_cursor = indexer.vecs.transactions.first_txout_index.cursor();
 
-        // Reusable buffers — avoid per-block allocation
+        // Reusable buffers: avoid per-block allocation. `tx_starts` holds the
+        // first txout index of each non-coinbase tx in the current block.
         let mut values: Vec<Sats> = Vec::new();
         let mut output_types: Vec<OutputType> = Vec::new();
+        let mut tx_starts: Vec<usize> = Vec::new();
 
-        for (idx, _h) in range.enumerate() {
-            let first_tx_index = first_tx_indexes[idx];
+        for idx in 0..range.len() {
             let next_first_tx_index = first_tx_indexes
                 .get(idx + 1)
                 .copied()
-                .unwrap_or(TxIndex::from(total_txs));
+                .unwrap_or(TxIndex::from(total_txs))
+                .to_usize();
+            let block_first_tx = first_tx_indexes[idx].to_usize() + 1;
+            let tx_count = next_first_tx_index - block_first_tx;
 
-            let next_out_first = out_firsts
+            let out_end = out_firsts
                 .get(idx + 1)
                 .copied()
                 .unwrap_or(TxOutIndex::from(total_outputs))
                 .to_usize();
-            let out_start = if first_tx_index.to_usize() + 1 < next_first_tx_index.to_usize() {
-                let target = first_tx_index.to_usize() + 1;
-                txout_cursor.advance(target - txout_cursor.position());
-                txout_cursor.next().unwrap().to_usize()
-            } else {
-                next_out_first
-            };
-            let out_end = next_out_first;
+
+            txout_cursor.advance(block_first_tx - txout_cursor.position());
+            tx_starts.clear();
+            for _ in 0..tx_count {
+                tx_starts.push(txout_cursor.next().unwrap().to_usize());
+            }
+            let out_start = tx_starts.first().copied().unwrap_or(out_end);
 
             indexer
                 .vecs
@@ -250,55 +286,21 @@ impl Vecs {
                 &mut output_types,
             );
 
-            let mut hist = [0u32; NUM_BINS];
-            for i in 0..values.len() {
-                if let Some(bin) = oracle.output_to_bin(values[i], output_types[i]) {
-                    hist[bin] += 1;
-                }
-            }
+            let tx_outputs = (0..tx_count).map(|tx| {
+                let lo = tx_starts[tx] - out_start;
+                let hi = tx_starts
+                    .get(tx + 1)
+                    .map(|s| s - out_start)
+                    .unwrap_or(out_end - out_start);
+                values[lo..hi]
+                    .iter()
+                    .copied()
+                    .zip(output_types[lo..hi].iter().copied())
+            });
+            let hist = PaymentFilter::for_height(range.start + idx).histogram(tx_outputs);
 
-            ref_bins.push(oracle.process_histogram(&hist));
+            let ref_bin = oracle.process_histogram(&hist);
+            on_block(range.start + idx, oracle, ref_bin);
         }
-
-        ref_bins
-    }
-}
-
-impl<M: StorageMode> Vecs<M> {
-    /// Returns an Oracle seeded from the last committed price, with the last
-    /// window_size blocks already processed. Ready for additional blocks (e.g. mempool).
-    pub fn live_oracle<IM: StorageMode>(&self, indexer: &Indexer<IM>) -> Result<Oracle> {
-        let config = Config::default();
-        let safe_lengths = indexer.safe_lengths();
-        let height = safe_lengths.height.to_usize();
-        let last_idx = self
-            .spot
-            .cents
-            .height
-            .len()
-            .checked_sub(1)
-            .ok_or(Error::NotFound(
-                "oracle prices not yet computed".to_string(),
-            ))?;
-        let last_cents = self
-            .spot
-            .cents
-            .height
-            .collect_one_at(last_idx)
-            .ok_or(Error::NotFound(
-                "oracle prices not yet computed".to_string(),
-            ))?;
-        let seed_bin = cents_to_bin(last_cents.inner() as f64);
-        let window_size = config.window_size;
-        let oracle = Oracle::from_checkpoint(seed_bin, config, |o| {
-            Vecs::feed_blocks_capped(
-                o,
-                indexer,
-                height.saturating_sub(window_size)..height,
-                &safe_lengths,
-            );
-        });
-
-        Ok(oracle)
     }
 }

crates/brk_computer/src/price/mod.rs

@@ -4,6 +4,7 @@ pub(crate) mod ohlcs;
 
 use std::path::Path;
 
+use brk_oracle::VERSION as ORACLE_VERSION;
 use brk_traversable::Traversable;
 use brk_types::Version;
 use vecdb::{Database, ReadOnlyClone, Rw, StorageMode};
@@ -20,7 +21,7 @@ use crate::{
 use by_unit::{OhlcByUnit, PriceByUnit, SplitByUnit, SplitCloseByUnit, SplitIndexesByUnit};
 use ohlcs::{LazyOhlcVecs, OhlcVecs};
 
-pub const DB_NAME: &str = "prices";
+pub const DB_NAME: &str = "price";
 
 #[derive(Traversable)]
 pub struct Vecs<M: StorageMode = Rw> {
@@ -49,7 +50,9 @@ impl Vecs {
         version: Version,
         indexes: &indexes::Vecs,
     ) -> brk_error::Result<Self> {
-        let version = version + Version::new(11);
+        // `ORACLE_VERSION` folds in the on-chain oracle algorithm version so
+        // every price-derived module invalidates when computed prices change.
+        let version = version + Version::new(11 + ORACLE_VERSION);
 
         let price_cents = CachedPerBlock::forced_import(db, "price_cents", version, indexes)?;