global: opreturn

.gitignore

@@ -18,6 +18,7 @@ _*
 /*.py
 /*.json
 /*.html
+!/btc-cycle-sim.html
 /research
 /filter_*
 /heatmaps*
@@ -25,6 +26,7 @@ _*
 /playground
 /*.txt
 /*.csv
+/tmp
 
 # Logs
 *.log*

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.1"
+package.version = "0.3.6"
 package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 package.readme = "README.md"
@@ -35,57 +35,61 @@ 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.100", features = ["serde"] }
-brk_alloc = { version = "0.3.1", path = "crates/brk_alloc" }
-brk_bencher = { version = "0.3.1", path = "crates/brk_bencher" }
-brk_bindgen = { version = "0.3.1", path = "crates/brk_bindgen" }
-brk_cli = { version = "0.3.1", path = "crates/brk_cli" }
-brk_client = { version = "0.3.1", path = "crates/brk_client" }
-brk_cohort = { version = "0.3.1", path = "crates/brk_cohort" }
-brk_computer = { version = "0.3.1", path = "crates/brk_computer" }
-brk_error = { version = "0.3.1", path = "crates/brk_error" }
-brk_fetcher = { version = "0.3.1", path = "crates/brk_fetcher" }
-brk_indexer = { version = "0.3.1", path = "crates/brk_indexer" }
-brk_iterator = { version = "0.3.1", path = "crates/brk_iterator" }
-brk_logger = { version = "0.3.1", path = "crates/brk_logger" }
-brk_mempool = { version = "0.3.1", path = "crates/brk_mempool" }
-brk_oracle = { version = "0.3.1", path = "crates/brk_oracle" }
-brk_query = { version = "0.3.1", path = "crates/brk_query", features = ["tokio"] }
-brk_reader = { version = "0.3.1", path = "crates/brk_reader" }
-brk_rpc = { version = "0.3.1", path = "crates/brk_rpc" }
-brk_server = { version = "0.3.1", path = "crates/brk_server" }
-brk_store = { version = "0.3.1", path = "crates/brk_store" }
-brk_traversable = { version = "0.3.1", path = "crates/brk_traversable", features = ["pco", "derive"] }
-brk_traversable_derive = { version = "0.3.1", path = "crates/brk_traversable_derive" }
-brk_types = { version = "0.3.1", path = "crates/brk_types" }
-brk_website = { version = "0.3.1", path = "crates/brk_website" }
+bitcoin = { version = "0.32.101", features = ["serde"] }
+brk_alloc = { version = "0.3.6", path = "crates/brk_alloc" }
+brk_bencher = { version = "0.3.6", path = "crates/brk_bencher" }
+brk_bindgen = { version = "0.3.6", path = "crates/brk_bindgen" }
+brk_cli = { version = "0.3.6", path = "crates/brk_cli" }
+brk_client = { version = "0.3.6", path = "crates/brk_client" }
+brk_cohort = { version = "0.3.6", path = "crates/brk_cohort" }
+brk_computer = { version = "0.3.6", path = "crates/brk_computer" }
+brk_error = { version = "0.3.6", path = "crates/brk_error" }
+brk_fetcher = { version = "0.3.6", path = "crates/brk_fetcher" }
+brk_indexer = { version = "0.3.6", path = "crates/brk_indexer" }
+brk_iterator = { version = "0.3.6", path = "crates/brk_iterator" }
+brk_logger = { version = "0.3.6", path = "crates/brk_logger" }
+brk_mempool = { version = "0.3.6", path = "crates/brk_mempool" }
+brk_oracle = { version = "0.3.6", path = "crates/brk_oracle" }
+brk_query = { version = "0.3.6", path = "crates/brk_query", features = ["tokio"] }
+brk_reader = { version = "0.3.6", path = "crates/brk_reader" }
+brk_rpc = { version = "0.3.6", path = "crates/brk_rpc" }
+brk_server = { version = "0.3.6", path = "crates/brk_server" }
+brk_store = { version = "0.3.6", path = "crates/brk_store" }
+brk_traversable = { version = "0.3.6", path = "crates/brk_traversable", features = ["pco", "derive"] }
+brk_traversable_derive = { version = "0.3.6", path = "crates/brk_traversable_derive" }
+brk_types = { version = "0.3.6", path = "crates/brk_types" }
+brk_website = { version = "0.3.6", 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.14.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.1.4"
+fjall = { version = "=3.0.4", path = "../fjall" }
 indexmap = { version = "2.14.0", features = ["serde"] }
-jiff = { version = "0.2.28", features = ["perf-inline", "tz-system"], default-features = false }
+jiff = { version = "0.2.32", features = ["perf-inline", "tz-system"], default-features = false }
 owo-colors = "4.3.0"
 parking_lot = "0.12.5"
 pco = "1.0.2"
 rayon = "1.12.0"
-rustc-hash = "2.1.2"
+rapidhash = "4.5.1"
+rustc-hash = "2.1.3"
 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.150", features = ["float_roundtrip", "preserve_order"] }
-smallvec = "1.15.1"
+smallvec = "1.15.2"
 tokio = { version = "1.52.3", features = ["rt-multi-thread"] }
-tower-http = { version = "0.6.11", features = ["catch-panic", "compression-br", "compression-gzip", "compression-zstd", "cors", "normalize-path", "timeout", "trace"] }
+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"] }
-vecdb = { version = "0.10.3", features = ["derive", "serde_json", "pco", "schemars"] }
+vecdb = { version = "0.10.4", features = ["derive", "serde_json", "pco", "schemars"] }
 # vecdb = { path = "../anydb/crates/vecdb", features = ["derive", "serde_json", "pco", "schemars"] }
 
+[patch.crates-io]
+lsm-tree = { path = "../lsm-tree" }
+
 [workspace.metadata.release]
 shared-version = true
 tag-name = "v{{version}}"

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, cache?: boolean }}}} [options]",
+        "   * @param {{{{ signal?: AbortSignal, onValue?: (value: {}) => void, cache?: boolean, memCache?: 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, cache } = {}".to_string()
+        "{ signal, onValue, cache, memCache } = {}".to_string()
     } else {
-        format!("{}, {{ signal, onValue, cache }} = {{}}", params)
+        format!("{}, {{ signal, onValue, cache, memCache }} = {{}}", 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, cache })".to_string()
+        "this.getBytes(path, { signal, onValue, cache, memCache })".to_string()
     } else if endpoint.returns_json() {
-        "this.getJson(path, { signal, onValue, cache })".to_string()
+        "this.getJson(path, { signal, onValue, cache, memCache })".to_string()
     } else if endpoint.response_kind.text_is_numeric() {
-        "Number(await this.getText(path, { signal, cache, onValue: onValue ? (v) => onValue(Number(v)) : undefined }))".to_string()
+        "Number(await this.getText(path, { signal, cache, memCache, onValue: onValue ? (v) => onValue(Number(v)) : undefined }))".to_string()
     } else {
-        "this.getText(path, { signal, onValue, cache })".to_string()
+        "this.getText(path, { signal, onValue, cache, memCache })".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, cache }});"
+            "    if (format === 'csv') return this.getText(path, {{ signal, onValue, cache, memCache }});"
         )
         .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
  */
@@ -237,8 +243,8 @@ function _wrapSeriesData(raw) {{
  * @property {{(n: number) => RangeBuilder<T>}} first - Get first n items
  * @property {{(n: number) => RangeBuilder<T>}} last - Get last n items
  * @property {{(n: number) => SkippedBuilder<T>}} skip - Skip first n items, chain with take()
- * @property {{(onValue?: (value: SeriesData<T>) => void) => Promise<SeriesData<T>>}} fetch - Fetch all data
- * @property {{() => Promise<string>}} fetchCsv - Fetch all data as CSV
+ * @property {{(arg?: SeriesFetchArg<T>, options?: ClientFetchOptions<SeriesData<T>>) => Promise<SeriesData<T>>}} fetch - Fetch all data
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch all data as CSV
  * @property {{() => Promise<number>}} len - Get total number of data points
  * @property {{() => Promise<Version>}} version - Get the current version of the series
  * @property {{Thenable<T>}} then - Thenable (await endpoint)
@@ -253,8 +259,8 @@ function _wrapSeriesData(raw) {{
  * @property {{(n: number) => DateRangeBuilder<T>}} first - Get first n items
  * @property {{(n: number) => DateRangeBuilder<T>}} last - Get last n items
  * @property {{(n: number) => DateSkippedBuilder<T>}} skip - Skip first n items, chain with take()
- * @property {{(onValue?: (value: DateSeriesData<T>) => void) => Promise<DateSeriesData<T>>}} fetch - Fetch all data
- * @property {{() => Promise<string>}} fetchCsv - Fetch all data as CSV
+ * @property {{(arg?: DateSeriesFetchArg<T>, options?: ClientFetchOptions<DateSeriesData<T>>) => Promise<DateSeriesData<T>>}} fetch - Fetch all data
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch all data as CSV
  * @property {{() => Promise<number>}} len - Get total number of data points
  * @property {{() => Promise<Version>}} version - Get the current version of the series
  * @property {{DateThenable<T>}} then - Thenable (await endpoint)
@@ -263,41 +269,53 @@ function _wrapSeriesData(raw) {{
 
 /** @typedef {{SeriesEndpoint<any>}} AnySeriesEndpoint */
 
+/**
+ * @template T
+ * @typedef {{Object}} ClientFetchOptions
+ * @property {{AbortSignal}} [signal] - Abort this request
+ * @property {{boolean}} [cache] - Use HTTP/browser/client caches. Set false for a no-store network fetch.
+ * @property {{boolean}} [memCache] - Use the parsed in-memory response cache. Set false for large one-shot reads.
+ * @property {{(value: T) => void}} [onValue] - Receive stale/fresh values as they arrive
+ */
+
+/** @template T @typedef {{ClientFetchOptions<SeriesData<T>> | ((value: SeriesData<T>) => void)}} SeriesFetchArg */
+/** @template T @typedef {{ClientFetchOptions<DateSeriesData<T>> | ((value: DateSeriesData<T>) => void)}} DateSeriesFetchArg */
+
 /** @template T @typedef {{Object}} SingleItemBuilder
- * @property {{(onValue?: (value: SeriesData<T>) => void) => Promise<SeriesData<T>>}} fetch - Fetch the item
- * @property {{() => Promise<string>}} fetchCsv - Fetch as CSV
+ * @property {{(arg?: SeriesFetchArg<T>, options?: ClientFetchOptions<SeriesData<T>>) => Promise<SeriesData<T>>}} fetch - Fetch the item
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch as CSV
  * @property {{Thenable<T>}} then - Thenable
  */
 
 /** @template T @typedef {{Object}} DateSingleItemBuilder
- * @property {{(onValue?: (value: DateSeriesData<T>) => void) => Promise<DateSeriesData<T>>}} fetch - Fetch the item
- * @property {{() => Promise<string>}} fetchCsv - Fetch as CSV
+ * @property {{(arg?: DateSeriesFetchArg<T>, options?: ClientFetchOptions<DateSeriesData<T>>) => Promise<DateSeriesData<T>>}} fetch - Fetch the item
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch as CSV
  * @property {{DateThenable<T>}} then - Thenable
  */
 
 /** @template T @typedef {{Object}} SkippedBuilder
  * @property {{(n: number) => RangeBuilder<T>}} take - Take n items after skipped position
- * @property {{(onValue?: (value: SeriesData<T>) => void) => Promise<SeriesData<T>>}} fetch - Fetch from skipped position to end
- * @property {{() => Promise<string>}} fetchCsv - Fetch as CSV
+ * @property {{(arg?: SeriesFetchArg<T>, options?: ClientFetchOptions<SeriesData<T>>) => Promise<SeriesData<T>>}} fetch - Fetch from skipped position to end
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch as CSV
  * @property {{Thenable<T>}} then - Thenable
  */
 
 /** @template T @typedef {{Object}} DateSkippedBuilder
  * @property {{(n: number) => DateRangeBuilder<T>}} take - Take n items after skipped position
- * @property {{(onValue?: (value: DateSeriesData<T>) => void) => Promise<DateSeriesData<T>>}} fetch - Fetch from skipped position to end
- * @property {{() => Promise<string>}} fetchCsv - Fetch as CSV
+ * @property {{(arg?: DateSeriesFetchArg<T>, options?: ClientFetchOptions<DateSeriesData<T>>) => Promise<DateSeriesData<T>>}} fetch - Fetch from skipped position to end
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch as CSV
  * @property {{DateThenable<T>}} then - Thenable
  */
 
 /** @template T @typedef {{Object}} RangeBuilder
- * @property {{(onValue?: (value: SeriesData<T>) => void) => Promise<SeriesData<T>>}} fetch - Fetch the range
- * @property {{() => Promise<string>}} fetchCsv - Fetch as CSV
+ * @property {{(arg?: SeriesFetchArg<T>, options?: ClientFetchOptions<SeriesData<T>>) => Promise<SeriesData<T>>}} fetch - Fetch the range
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch as CSV
  * @property {{Thenable<T>}} then - Thenable
  */
 
 /** @template T @typedef {{Object}} DateRangeBuilder
- * @property {{(onValue?: (value: DateSeriesData<T>) => void) => Promise<DateSeriesData<T>>}} fetch - Fetch the range
- * @property {{() => Promise<string>}} fetchCsv - Fetch as CSV
+ * @property {{(arg?: DateSeriesFetchArg<T>, options?: ClientFetchOptions<DateSeriesData<T>>) => Promise<DateSeriesData<T>>}} fetch - Fetch the range
+ * @property {{(options?: ClientFetchOptions<string>) => Promise<string>}} fetchCsv - Fetch as CSV
  * @property {{DateThenable<T>}} then - Thenable
  */
 
@@ -344,8 +362,8 @@ function _endpoint(client, name, index) {{
    * @returns {{DateRangeBuilder<T>}}
    */
   const rangeBuilder = (start, end) => ({{
-    fetch(onValue) {{ return client._fetchSeriesData(buildPath(start, end), onValue); }},
-    fetchCsv() {{ return client.getText(buildPath(start, end, 'csv')); }},
+    fetch(arg, options) {{ return client._fetchSeriesData(buildPath(start, end), arg, options); }},
+    fetchCsv(options) {{ return client.getText(buildPath(start, end, 'csv'), options); }},
     then(resolve, reject) {{ return this.fetch().then(resolve, reject); }},
   }});
 
@@ -354,8 +372,8 @@ function _endpoint(client, name, index) {{
    * @returns {{DateSingleItemBuilder<T>}}
    */
   const singleItemBuilder = (idx) => ({{
-    fetch(onValue) {{ return client._fetchSeriesData(buildPath(idx, idx + 1), onValue); }},
-    fetchCsv() {{ return client.getText(buildPath(idx, idx + 1, 'csv')); }},
+    fetch(arg, options) {{ return client._fetchSeriesData(buildPath(idx, idx + 1), arg, options); }},
+    fetchCsv(options) {{ return client.getText(buildPath(idx, idx + 1, 'csv'), options); }},
     then(resolve, reject) {{ return this.fetch().then(resolve, reject); }},
   }});
 
@@ -365,8 +383,8 @@ function _endpoint(client, name, index) {{
    */
   const skippedBuilder = (start) => ({{
     take(n) {{ return rangeBuilder(start, start + n); }},
-    fetch(onValue) {{ return client._fetchSeriesData(buildPath(start, undefined), onValue); }},
-    fetchCsv() {{ return client.getText(buildPath(start, undefined, 'csv')); }},
+    fetch(arg, options) {{ return client._fetchSeriesData(buildPath(start, undefined), arg, options); }},
+    fetchCsv(options) {{ return client.getText(buildPath(start, undefined, 'csv'), options); }},
     then(resolve, reject) {{ return this.fetch().then(resolve, reject); }},
   }});
 
@@ -381,8 +399,8 @@ function _endpoint(client, name, index) {{
     first(n) {{ return rangeBuilder(undefined, n); }},
     last(n) {{ return n === 0 ? rangeBuilder(undefined, 0) : rangeBuilder(-n, undefined); }},
     skip(n) {{ return skippedBuilder(n); }},
-    fetch(onValue) {{ return client._fetchSeriesData(buildPath(), onValue); }},
-    fetchCsv() {{ return client.getText(buildPath(undefined, undefined, 'csv')); }},
+    fetch(arg, options) {{ return client._fetchSeriesData(buildPath(), arg, options); }},
+    fetchCsv(options) {{ return client.getText(buildPath(undefined, undefined, 'csv'), options); }},
     len() {{ return client.getSeriesLen(name, index); }},
     version() {{ return client.getSeriesVersion(name, index); }},
     then(resolve, reject) {{ return this.fetch().then(resolve, reject); }},
@@ -403,6 +421,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);
@@ -478,10 +499,10 @@ class BrkClientBase {{
    * @template T
    * @param {{string}} path
    * @param {{(res: Response) => Promise<T>}} parse - Response body reader
-   * @param {{{{ onValue?: (value: T) => void, signal?: AbortSignal, cache?: boolean }}}} [options]
+   * @param {{ClientFetchOptions<T>}} [options]
    * @returns {{Promise<T>}}
    */
-  async _getCached(path, parse, {{ onValue, signal, cache = true }} = {{}}) {{
+  async _getCached(path, parse, {{ onValue, signal, cache = true, memCache = true }} = {{}}) {{
     if (!cache) {{
       const res = await this.get(path, {{ signal, cache }});
       const value = await parse(res);
@@ -490,8 +511,9 @@ class BrkClientBase {{
     }}
 
     const url = `${{this.baseUrl}}${{path}}`;
+    const useMemCache = memCache !== false;
     /** @type {{_MemEntry<T> | undefined}} */
-    const memHit = this._memGet(url);
+    const memHit = useMemCache ? this._memGet(url) : undefined;
     const browserCache = this._browserCache;
 
     // L1 fast path: deliver from memCache, revalidate via network.
@@ -504,7 +526,7 @@ class BrkClientBase {{
         if (netEtag && netEtag === memHit.etag) return memHit.value;
         const cloned = browserCache ? res.clone() : null;
         const value = await parse(res);
-        this._memSet(url, netEtag, value);
+        if (useMemCache) this._memSet(url, netEtag, value);
         if (onValue) onValue(value);
         if (cloned && browserCache) {{
           const cacheStore = browserCache;
@@ -523,7 +545,7 @@ class BrkClientBase {{
           if (!res || networkSettled) return null;
           const value = await parse(res);
           if (networkSettled) return value;
-          this._memSet(url, res.headers.get('ETag'), value);
+          if (useMemCache) this._memSet(url, res.headers.get('ETag'), value);
           onValue(value);
           return value;
         }}).catch(() => null)
@@ -534,11 +556,11 @@ class BrkClientBase {{
       networkSettled = true;
       const netEtag = res.headers.get('ETag');
       // Stale won and populated memCache with matching ETag → reuse, skip parse + second onValue.
-      const populated = /** @type {{_MemEntry<T> | undefined}} */ (this._memGet(url));
+      const populated = useMemCache ? /** @type {{_MemEntry<T> | undefined}} */ (this._memGet(url)) : undefined;
       if (populated && netEtag && netEtag === populated.etag) return populated.value;
       const cloned = browserCache ? res.clone() : null;
       const value = await parse(res);
-      this._memSet(url, netEtag, value);
+      if (useMemCache) this._memSet(url, netEtag, value);
       if (onValue) onValue(value);
       if (cloned && browserCache) {{
         const cacheStore = browserCache;
@@ -556,7 +578,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, cache?: boolean }}}} [options]
+   * @param {{ClientFetchOptions<T>}} [options]
    * @returns {{Promise<T>}}
    */
   getJson(path, options) {{
@@ -567,7 +589,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, cache?: boolean }}}} [options]
+   * @param {{ClientFetchOptions<string>}} [options]
    * @returns {{Promise<string>}}
    */
   getText(path, options) {{
@@ -578,7 +600,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, cache?: boolean }}}} [options]
+   * @param {{ClientFetchOptions<Uint8Array>}} [options]
    * @returns {{Promise<Uint8Array>}}
    */
   getBytes(path, options) {{
@@ -650,12 +672,17 @@ class BrkClientBase {{
    * Fetch series data and wrap with helper methods (internal)
    * @template T
    * @param {{string}} path
-   * @param {{(value: DateSeriesData<T>) => void}} [onValue]
+   * @param {{DateSeriesFetchArg<T>}} [arg]
+   * @param {{ClientFetchOptions<DateSeriesData<T>>}} [options]
    * @returns {{Promise<DateSeriesData<T>>}}
    */
-  async _fetchSeriesData(path, onValue) {{
+  async _fetchSeriesData(path, arg, options) {{
+    const requestOptions = typeof arg === 'function'
+      ? {{ ...(options ?? {{}}), onValue: arg }}
+      : {{ ...(arg ?? {{}}), ...(options ?? {{}}) }};
+    const onValue = requestOptions.onValue;
     const wrappedOnValue = onValue ? (/** @type {{SeriesData<T>}} */ raw) => onValue(_wrapSeriesData(raw)) : undefined;
-    const raw = await this.getJson(path, {{ onValue: wrappedOnValue }});
+    const raw = await this.getJson(path, {{ ...requestOptions, onValue: wrappedOnValue }});
     return _wrapSeriesData(raw);
   }}
 }}
@@ -679,6 +706,160 @@ const _p = (prefix, acc) => acc ? `${{prefix}}_${{acc}}` : prefix;
 "#
     )
     .unwrap();
+    output.push_str(r##"
+const _MASK_64 = 0xffffffffffffffffn;
+const _RAPIDHASH_SECRETS = /** @type {const} */ ([
+  0x2d358dccaa6c78a5n,
+  0x8bb84b93962eacc9n,
+  0x4b33a62ed433d4a3n,
+  0x4d5a2da51de1aa47n,
+  0xa0761d6478bd642fn,
+  0xe7037ed1a0b428dbn,
+  0x90ed1765281c388cn,
+]);
+const _RAPIDHASH_SEED = _rapidHashSeed(0n);
+
+/** @param {bigint} value */
+function _u64(value) {
+  return value & _MASK_64;
+}
+
+/** @param {bigint} left @param {bigint} right */
+function _rapidMix(left, right) {
+  const result = _u64(left) * _u64(right);
+  return _u64(result) ^ _u64(result >> 64n);
+}
+
+/** @param {bigint} left @param {bigint} right @returns {[bigint, bigint]} */
+function _rapidMum(left, right) {
+  const result = _u64(left) * _u64(right);
+  return [_u64(result), _u64(result >> 64n)];
+}
+
+/** @param {bigint} seed */
+function _rapidHashSeed(seed) {
+  return _u64(seed ^ _rapidMix(seed ^ _RAPIDHASH_SECRETS[2], _RAPIDHASH_SECRETS[1]));
+}
+
+/** @param {Uint8Array} bytes @param {number} offset */
+function _readU32(bytes, offset) {
+  return (
+    BigInt(bytes[offset]) |
+    (BigInt(bytes[offset + 1]) << 8n) |
+    (BigInt(bytes[offset + 2]) << 16n) |
+    (BigInt(bytes[offset + 3]) << 24n)
+  );
+}
+
+/** @param {Uint8Array} bytes @param {number} offset */
+function _readU64(bytes, offset) {
+  return _readU32(bytes, offset) | (_readU32(bytes, offset + 4) << 32n);
+}
+
+/** @param {Uint8Array | ArrayBuffer | ArrayBufferView | number[]} payload */
+function _asUint8Array(payload) {
+  if (payload instanceof Uint8Array) return payload;
+  if (payload instanceof ArrayBuffer) return new Uint8Array(payload);
+  if (ArrayBuffer.isView(payload)) return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
+  if (Array.isArray(payload)) return new Uint8Array(payload);
+  throw new Error("Expected address payload bytes");
+}
+
+/** @param {Uint8Array | ArrayBuffer | ArrayBufferView | number[]} payload */
+function _rapidHashV3(payload) {
+  const bytes = _asUint8Array(payload);
+  const length = bytes.length;
+  if (length === 0) throw new Error("Expected a non-empty address payload");
+  if (length > 65) throw new Error("Expected at most 65 address payload bytes");
+
+  let seed = _RAPIDHASH_SEED;
+  let a = 0n;
+  let b = 0n;
+  let remainder;
+
+  if (length <= 16) {
+    if (length >= 4) {
+      seed ^= BigInt(length);
+      if (length >= 8) {
+        a ^= _readU64(bytes, 0);
+        b ^= _readU64(bytes, length - 8);
+      } else {
+        a ^= _readU32(bytes, 0);
+        b ^= _readU32(bytes, length - 4);
+      }
+    } else if (length > 0) {
+      a ^= (BigInt(bytes[0]) << 45n) | BigInt(bytes[length - 1]);
+      b ^= BigInt(bytes[length >> 1]);
+    }
+    remainder = BigInt(length);
+  } else {
+    seed = _rapidMix(_readU64(bytes, 0) ^ _RAPIDHASH_SECRETS[2], _readU64(bytes, 8) ^ seed);
+    if (length > 32) {
+      seed = _rapidMix(_readU64(bytes, 16) ^ _RAPIDHASH_SECRETS[2], _readU64(bytes, 24) ^ seed);
+      if (length > 48) {
+        seed = _rapidMix(_readU64(bytes, 32) ^ _RAPIDHASH_SECRETS[1], _readU64(bytes, 40) ^ seed);
+        if (length > 64) {
+          seed = _rapidMix(_readU64(bytes, 48) ^ _RAPIDHASH_SECRETS[1], _readU64(bytes, 56) ^ seed);
+        }
+      }
+    }
+    remainder = BigInt(length);
+    a ^= _readU64(bytes, length - 16) ^ remainder;
+    b ^= _readU64(bytes, length - 8);
+  }
+
+  a ^= _RAPIDHASH_SECRETS[1];
+  b ^= seed;
+  [a, b] = _rapidMum(a, b);
+  return _rapidMix(a ^ 0xaaaaaaaaaaaaaaaan, b ^ _RAPIDHASH_SECRETS[1] ^ remainder);
+}
+
+/** @param {number} nibbles */
+function _validateHashPrefixNibbles(nibbles) {
+  if (!Number.isInteger(nibbles) || nibbles < 1 || nibbles > 16) {
+    throw new Error("Expected hash-prefix length from 1 to 16 hex nibbles");
+  }
+}
+
+/** @param {OutputType} addrType @returns {number[]} */
+function _addressPayloadLengths(addrType) {
+  switch (addrType) {
+    case "p2a": return [2];
+    case "p2pk": return [33, 65];
+    case "p2pkh":
+    case "p2sh":
+    case "v0_p2wpkh": return [20];
+    case "v0_p2wsh":
+    case "v1_p2tr": return [32];
+    default:
+      throw new Error(`Unsupported address type for address payload hash-prefix: ${addrType}`);
+  }
+}
+
+/**
+ * @param {OutputType} addrType
+ * @param {Uint8Array | ArrayBuffer | ArrayBufferView | number[]} payload
+ */
+function _validateAddressPayloadForType(addrType, payload) {
+  const length = _asUint8Array(payload).length;
+  const expected = _addressPayloadLengths(addrType);
+  if (!expected.includes(length)) {
+    throw new Error(`Expected ${addrType} address payload length ${expected.join(" or ")} bytes`);
+  }
+}
+
+/**
+ * Compute the RapidHash v3 hash-prefix used by `/api/address/hash-prefix/{addr_type}/{prefix}`.
+ * @param {Uint8Array | ArrayBuffer | ArrayBufferView | number[]} payload - Raw address payload bytes
+ * @param {number} nibbles - Prefix length from 1 to 16 hex nibbles
+ * @returns {string}
+ */
+function addressPayloadHashPrefix(payload, nibbles) {
+  _validateHashPrefixNibbles(nibbles);
+  return _rapidHashV3(payload).toString(16).padStart(16, "0").slice(0, nibbles);
+}
+
+"##);
 }
 
 /// Generate static constants for the BrkClient class.

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

@@ -111,6 +111,32 @@ pub fn generate_main_client(
     writeln!(output, "    this.series = this._buildTree();").unwrap();
     writeln!(output, "  }}\n").unwrap();
 
+    output.push_str(r##"  /**
+   * Compute the RapidHash v3 hash-prefix for raw address payload bytes.
+   * @param {Uint8Array | ArrayBuffer | ArrayBufferView | number[]} payload
+   * @param {number} nibbles
+   * @returns {string}
+   */
+  static addressPayloadHashPrefix(payload, nibbles) {
+    return addressPayloadHashPrefix(payload, nibbles);
+  }
+
+  /**
+   * Fetch address hash-prefix matches from raw address payload bytes.
+   * @param {OutputType} addrType
+   * @param {Uint8Array | ArrayBuffer | ArrayBufferView | number[]} payload - Raw payload bytes matching addrType length
+   * @param {number} nibbles
+   * @param {{ signal?: AbortSignal, onValue?: (value: AddrHashPrefixMatches) => void, cache?: boolean, memCache?: boolean }} [options]
+   * @returns {Promise<AddrHashPrefixMatches>}
+   */
+  getAddressPayloadHashPrefixMatches(addrType, payload, nibbles, options = {}) {
+    _validateAddressPayloadForType(addrType, payload);
+    const prefix = addressPayloadHashPrefix(payload, nibbles);
+    return this.getAddressHashPrefixMatches(addrType, prefix, options);
+  }
+
+"##);
+
     writeln!(output, "  /**").unwrap();
     writeln!(output, "   * @private").unwrap();
     writeln!(output, "   * @returns {{SeriesTree}}").unwrap();
@@ -161,7 +187,11 @@ pub fn generate_main_client(
 
     writeln!(output, "}}\n").unwrap();
 
-    writeln!(output, "export {{ BrkClient, BrkError }};").unwrap();
+    writeln!(
+        output,
+        "export {{ BrkClient, BrkError, addressPayloadHashPrefix }};"
+    )
+    .unwrap();
 }
 
 #[allow(clippy::too_many_arguments)]

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

@@ -84,6 +84,23 @@ pub fn generate_main_client(output: &mut String, endpoints: &[Endpoint]) {
     .unwrap();
     writeln!(output, "        return _date_to_index(index, d)").unwrap();
     writeln!(output).unwrap();
+
+    output.push_str(r#"    @staticmethod
+    def address_payload_hash_prefix(payload: Union[bytes, bytearray, memoryview], nibbles: int) -> str:
+        """Compute the RapidHash v3 hash-prefix for raw address payload bytes."""
+        return address_payload_hash_prefix(payload, nibbles)
+
+    def get_address_payload_hash_prefix_matches(
+        self,
+        addr_type: OutputType,
+        payload: Union[bytes, bytearray, memoryview],
+        nibbles: int,
+    ) -> AddrHashPrefixMatches:
+        """Fetch address hash-prefix matches from raw payload bytes matching addr_type length."""
+        _validate_address_payload_for_type(addr_type, payload)
+        return self.get_address_hash_prefix_matches(addr_type, address_payload_hash_prefix(payload, nibbles))
+
+"#);
     // Generate API methods
     generate_api_methods(output, endpoints);
 }

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

@@ -147,6 +147,125 @@ def _p(prefix: str, acc: str) -> str:
 "#
     )
     .unwrap();
+    output.push_str(r#"
+_MASK_64 = (1 << 64) - 1
+_RAPIDHASH_SECRETS = (
+    0x2d358dccaa6c78a5,
+    0x8bb84b93962eacc9,
+    0x4b33a62ed433d4a3,
+    0x4d5a2da51de1aa47,
+    0xa0761d6478bd642f,
+    0xe7037ed1a0b428db,
+    0x90ed1765281c388c,
+)
+_RAPIDHASH_SEED = 0
+
+
+def _u64(value: int) -> int:
+    return value & _MASK_64
+
+
+def _rapid_mix(left: int, right: int) -> int:
+    result = _u64(left) * _u64(right)
+    return _u64(result) ^ _u64(result >> 64)
+
+
+def _rapid_mum(left: int, right: int) -> Tuple[int, int]:
+    result = _u64(left) * _u64(right)
+    return _u64(result), _u64(result >> 64)
+
+
+def _rapid_hash_seed(seed: int) -> int:
+    return _u64(seed ^ _rapid_mix(seed ^ _RAPIDHASH_SECRETS[2], _RAPIDHASH_SECRETS[1]))
+
+
+_RAPIDHASH_SEED = _rapid_hash_seed(0)
+
+
+def _read_u32(data: bytes, offset: int) -> int:
+    return int.from_bytes(data[offset:offset + 4], "little")
+
+
+def _read_u64(data: bytes, offset: int) -> int:
+    return int.from_bytes(data[offset:offset + 8], "little")
+
+
+def _rapid_hash_v3(payload: Union[bytes, bytearray, memoryview]) -> int:
+    data = bytes(payload)
+    length = len(data)
+    if length == 0:
+        raise ValueError("Expected a non-empty address payload")
+    if length > 65:
+        raise ValueError("Expected at most 65 address payload bytes")
+
+    seed = _RAPIDHASH_SEED
+    a = 0
+    b = 0
+
+    if length <= 16:
+        if length >= 4:
+            seed ^= length
+            if length >= 8:
+                a ^= _read_u64(data, 0)
+                b ^= _read_u64(data, length - 8)
+            else:
+                a ^= _read_u32(data, 0)
+                b ^= _read_u32(data, length - 4)
+        elif length > 0:
+            a ^= (data[0] << 45) | data[length - 1]
+            b ^= data[length >> 1]
+        remainder = length
+    else:
+        if length > 16:
+            seed = _rapid_mix(_read_u64(data, 0) ^ _RAPIDHASH_SECRETS[2], _read_u64(data, 8) ^ seed)
+            if length > 32:
+                seed = _rapid_mix(_read_u64(data, 16) ^ _RAPIDHASH_SECRETS[2], _read_u64(data, 24) ^ seed)
+                if length > 48:
+                    seed = _rapid_mix(_read_u64(data, 32) ^ _RAPIDHASH_SECRETS[1], _read_u64(data, 40) ^ seed)
+                    if length > 64:
+                        seed = _rapid_mix(_read_u64(data, 48) ^ _RAPIDHASH_SECRETS[1], _read_u64(data, 56) ^ seed)
+        remainder = length
+        a ^= _read_u64(data, length - 16) ^ remainder
+        b ^= _read_u64(data, length - 8)
+
+    a ^= _RAPIDHASH_SECRETS[1]
+    b ^= seed
+    a, b = _rapid_mum(a, b)
+    return _rapid_mix(a ^ 0xaaaaaaaaaaaaaaaa, b ^ _RAPIDHASH_SECRETS[1] ^ remainder)
+
+
+def _validate_hash_prefix_nibbles(nibbles: int) -> None:
+    if isinstance(nibbles, bool) or not isinstance(nibbles, int) or nibbles < 1 or nibbles > 16:
+        raise ValueError("Expected hash-prefix length from 1 to 16 hex nibbles")
+
+
+def _address_payload_lengths(addr_type: OutputType) -> Tuple[int, ...]:
+    if addr_type == "p2a":
+        return (2,)
+    if addr_type == "p2pk":
+        return (33, 65)
+    if addr_type in ("p2pkh", "p2sh", "v0_p2wpkh"):
+        return (20,)
+    if addr_type in ("v0_p2wsh", "v1_p2tr"):
+        return (32,)
+    raise ValueError(f"Unsupported address type for address payload hash-prefix: {addr_type}")
+
+
+def _validate_address_payload_for_type(addr_type: OutputType, payload: Union[bytes, bytearray, memoryview]) -> None:
+    length = len(bytes(payload))
+    expected = _address_payload_lengths(addr_type)
+    if length not in expected:
+        joined = " or ".join(str(value) for value in expected)
+        raise ValueError(f"Expected {addr_type} address payload length {joined} bytes")
+
+
+def address_payload_hash_prefix(payload: Union[bytes, bytearray, memoryview], nibbles: int) -> str:
+    """Compute the RapidHash v3 hash-prefix used by `/api/address/hash-prefix/{addr_type}/{prefix}`."""
+    _validate_hash_prefix_nibbles(nibbles)
+    return f"{_rapid_hash_v3(payload):016x}"[:nibbles]
+
+
+"#);
 }
 
 /// Generate the SeriesData and SeriesEndpoint classes

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

@@ -76,6 +76,36 @@ impl BrkClient {{
     )
     .unwrap();
 
+    output.push_str(r#"    /// Decode a mainnet Bitcoin address into the BRK address type and raw payload bytes.
+    pub fn decode_address_payload(address: &str) -> Result<AddressPayload> {
+        decode_address_payload(address)
+    }
+
+    /// Compute the RapidHash v3 hash-prefix for raw address payload bytes.
+    pub fn address_payload_hash_prefix(payload: &[u8], nibbles: usize) -> Result<String> {
+        address_payload_hash_prefix(payload, nibbles)
+    }
+
+    /// Decode a mainnet Bitcoin address and compute its hash prefix.
+    pub fn address_hash_prefix(address: &str, nibbles: usize) -> Result<AddressHashPrefix> {
+        address_hash_prefix(address, nibbles)
+    }
+
+    /// Fetch address hash-prefix matches from raw payload bytes matching `addr_type` length.
+    pub fn get_address_payload_hash_prefix_matches(&self, addr_type: OutputType, payload: &[u8], nibbles: usize) -> Result<AddrHashPrefixMatches> {
+        validate_address_payload_for_type(addr_type, payload)?;
+        let prefix = address_payload_hash_prefix(payload, nibbles)?;
+        self.get_address_hash_prefix_matches(addr_type, &prefix)
+    }
+
+    /// Fetch address hash-prefix matches for a mainnet Bitcoin address.
+    pub fn get_address_hash_prefix_matches_for_address(&self, address: &str, nibbles: usize) -> Result<AddrHashPrefixMatches> {
+        let hashed = address_hash_prefix(address, nibbles)?;
+        self.get_address_hash_prefix_matches(hashed.addr_type, &hashed.prefix)
+    }
+
+"#);
+
     generate_api_methods(output, endpoints);
 
     writeln!(output, "}}").unwrap();
@@ -118,6 +148,23 @@ fn generate_get_method(output: &mut String, endpoint: &Endpoint) {
         "get_text"
     };
 
+    if endpoint.path == "/api/address/hash-prefix/{addr_type}/{prefix}" {
+        writeln!(
+            output,
+            "        let addr_type = address_payload_type_path(addr_type)?;"
+        )
+        .unwrap();
+        writeln!(
+            output,
+            "        self.base.{}(&format!(\"{}\"{}))",
+            fetch_method, path, index_arg
+        )
+        .unwrap();
+        writeln!(output, "    }}").unwrap();
+        writeln!(output).unwrap();
+        return;
+    }
+
     if endpoint.query_params.is_empty() {
         writeln!(
             output,

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

@@ -11,7 +11,8 @@ use crate::{
 pub fn generate_imports(output: &mut String) {
     writeln!(
         output,
-        r#"use std::sync::Arc;
+        r#"use std::str::FromStr;
+use std::sync::Arc;
 use std::ops::{{Bound, RangeBounds}};
 use serde::de::DeserializeOwned;
 pub use brk_cohort::*;
@@ -43,6 +44,97 @@ impl std::error::Error for BrkError {{}}
 /// Result type for BRK client operations.
 pub type Result<T> = std::result::Result<T, BrkError>;
 
+/// BRK address type and raw payload bytes used by the hash-prefix index.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AddressPayload {{
+    pub addr_type: OutputType,
+    pub payload: Vec<u8>,
+}}
+
+/// BRK address type and leading hex nibbles of the address-payload hash.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AddressHashPrefix {{
+    pub addr_type: OutputType,
+    pub prefix: String,
+}}
+
+/// Compute the RapidHash v3 hash-prefix used by `/api/address/hash-prefix/{{addr_type}}/{{prefix}}`.
+pub fn address_payload_hash_prefix(payload: &[u8], nibbles: usize) -> Result<String> {{
+    if payload.is_empty() {{
+        return Err(BrkError {{ message: "Expected a non-empty address payload".to_string() }});
+    }}
+    if payload.len() > 65 {{
+        return Err(BrkError {{ message: "Expected at most 65 address payload bytes".to_string() }});
+    }}
+    if !(1..=16).contains(&nibbles) {{
+        return Err(BrkError {{ message: "Expected hash-prefix length from 1 to 16 hex nibbles".to_string() }});
+    }}
+    Ok(format!("{{:016x}}", rapidhash::v3::rapidhash_v3(payload))[..nibbles].to_string())
+}}
+
+fn validate_address_payload_for_type(addr_type: OutputType, payload: &[u8]) -> Result<()> {{
+    let expected: &[usize] = match addr_type {{
+        OutputType::P2A => &[2],
+        OutputType::P2PK33 => &[33],
+        OutputType::P2PK65 => &[65],
+        OutputType::P2PKH | OutputType::P2SH | OutputType::P2WPKH => &[20],
+        OutputType::P2WSH | OutputType::P2TR => &[32],
+        OutputType::P2MS | OutputType::OpReturn | OutputType::Empty | OutputType::Unknown => {{
+            return Err(BrkError {{ message: format!("Unsupported address type for address payload hash-prefix: {{addr_type:?}}") }});
+        }},
+    }};
+    let addr_type = address_payload_type_path(addr_type)?;
+
+    if !expected.contains(&payload.len()) {{
+        let joined = expected
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" or ");
+        return Err(BrkError {{ message: format!("Expected {{addr_type}} address payload length {{joined}} bytes") }});
+    }}
+
+    Ok(())
+}}
+
+fn address_payload_type_path(addr_type: OutputType) -> Result<&'static str> {{
+    match addr_type {{
+        OutputType::P2A => Ok("p2a"),
+        OutputType::P2PK33 | OutputType::P2PK65 => Ok("p2pk"),
+        OutputType::P2PKH => Ok("p2pkh"),
+        OutputType::P2SH => Ok("p2sh"),
+        OutputType::P2WPKH => Ok("v0_p2wpkh"),
+        OutputType::P2WSH => Ok("v0_p2wsh"),
+        OutputType::P2TR => Ok("v1_p2tr"),
+        OutputType::P2MS | OutputType::OpReturn | OutputType::Empty | OutputType::Unknown => {{
+            Err(BrkError {{ message: format!("Unsupported address type for address payload hash-prefix: {{addr_type:?}}") }})
+        }},
+    }}
+}}
+
+/// Decode a mainnet Bitcoin address into the BRK address type and raw payload bytes.
+pub fn decode_address_payload(address: &str) -> Result<AddressPayload> {{
+    if address.is_empty() {{
+        return Err(BrkError {{ message: "Expected an address string".to_string() }});
+    }}
+    let addr_bytes = AddrBytes::from_str(address).map_err(|e| BrkError {{ message: e.to_string() }})?;
+    let addr_type = OutputType::from(&addr_bytes);
+
+    Ok(AddressPayload {{
+        addr_type,
+        payload: addr_bytes.as_slice().to_vec(),
+    }})
+}}
+
+/// Decode a mainnet Bitcoin address and compute its hash prefix.
+pub fn address_hash_prefix(address: &str, nibbles: usize) -> Result<AddressHashPrefix> {{
+    let decoded = decode_address_payload(address)?;
+    Ok(AddressHashPrefix {{
+        addr_type: decoded.addr_type,
+        prefix: address_payload_hash_prefix(&decoded.payload, nibbles)?,
+    }})
+}}
+
 /// Options for configuring the BRK client.
 #[derive(Debug, Clone)]
 pub struct BrkClientOptions {{

crates/brk_client/Cargo.toml

@@ -13,6 +13,7 @@ exclude = ["examples/"]
 [dependencies]
 brk_cohort = { workspace = true }
 brk_types = { workspace = true }
+rapidhash = { workspace = true }
 ureq = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

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

@@ -8,6 +8,7 @@
 #![allow(clippy::useless_format)]
 #![allow(clippy::unnecessary_to_owned)]
 
+use std::str::FromStr;
 use std::sync::Arc;
 use std::ops::{Bound, RangeBounds};
 use serde::de::DeserializeOwned;
@@ -32,6 +33,97 @@ impl std::error::Error for BrkError {}
 /// Result type for BRK client operations.
 pub type Result<T> = std::result::Result<T, BrkError>;
 
+/// BRK address type and raw payload bytes used by the hash-prefix index.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AddressPayload {
+    pub addr_type: OutputType,
+    pub payload: Vec<u8>,
+}
+
+/// BRK address type and leading hex nibbles of the address-payload hash.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AddressHashPrefix {
+    pub addr_type: OutputType,
+    pub prefix: String,
+}
+
+/// Compute the RapidHash v3 hash-prefix used by `/api/address/hash-prefix/{addr_type}/{prefix}`.
+pub fn address_payload_hash_prefix(payload: &[u8], nibbles: usize) -> Result<String> {
+    if payload.is_empty() {
+        return Err(BrkError { message: "Expected a non-empty address payload".to_string() });
+    }
+    if payload.len() > 65 {
+        return Err(BrkError { message: "Expected at most 65 address payload bytes".to_string() });
+    }
+    if !(1..=16).contains(&nibbles) {
+        return Err(BrkError { message: "Expected hash-prefix length from 1 to 16 hex nibbles".to_string() });
+    }
+    Ok(format!("{:016x}", rapidhash::v3::rapidhash_v3(payload))[..nibbles].to_string())
+}
+
+fn validate_address_payload_for_type(addr_type: OutputType, payload: &[u8]) -> Result<()> {
+    let expected: &[usize] = match addr_type {
+        OutputType::P2A => &[2],
+        OutputType::P2PK33 => &[33],
+        OutputType::P2PK65 => &[65],
+        OutputType::P2PKH | OutputType::P2SH | OutputType::P2WPKH => &[20],
+        OutputType::P2WSH | OutputType::P2TR => &[32],
+        OutputType::P2MS | OutputType::OpReturn | OutputType::Empty | OutputType::Unknown => {
+            return Err(BrkError { message: format!("Unsupported address type for address payload hash-prefix: {addr_type:?}") });
+        },
+    };
+    let addr_type = address_payload_type_path(addr_type)?;
+
+    if !expected.contains(&payload.len()) {
+        let joined = expected
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(" or ");
+        return Err(BrkError { message: format!("Expected {addr_type} address payload length {joined} bytes") });
+    }
+
+    Ok(())
+}
+
+fn address_payload_type_path(addr_type: OutputType) -> Result<&'static str> {
+    match addr_type {
+        OutputType::P2A => Ok("p2a"),
+        OutputType::P2PK33 | OutputType::P2PK65 => Ok("p2pk"),
+        OutputType::P2PKH => Ok("p2pkh"),
+        OutputType::P2SH => Ok("p2sh"),
+        OutputType::P2WPKH => Ok("v0_p2wpkh"),
+        OutputType::P2WSH => Ok("v0_p2wsh"),
+        OutputType::P2TR => Ok("v1_p2tr"),
+        OutputType::P2MS | OutputType::OpReturn | OutputType::Empty | OutputType::Unknown => {
+            Err(BrkError { message: format!("Unsupported address type for address payload hash-prefix: {addr_type:?}") })
+        },
+    }
+}
+
+/// Decode a mainnet Bitcoin address into the BRK address type and raw payload bytes.
+pub fn decode_address_payload(address: &str) -> Result<AddressPayload> {
+    if address.is_empty() {
+        return Err(BrkError { message: "Expected an address string".to_string() });
+    }
+    let addr_bytes = AddrBytes::from_str(address).map_err(|e| BrkError { message: e.to_string() })?;
+    let addr_type = OutputType::from(&addr_bytes);
+
+    Ok(AddressPayload {
+        addr_type,
+        payload: addr_bytes.as_slice().to_vec(),
+    })
+}
+
+/// Decode a mainnet Bitcoin address and compute its hash prefix.
+pub fn address_hash_prefix(address: &str, nibbles: usize) -> Result<AddressHashPrefix> {
+    let decoded = decode_address_payload(address)?;
+    Ok(AddressHashPrefix {
+        addr_type: decoded.addr_type,
+        prefix: address_payload_hash_prefix(&decoded.payload, nibbles)?,
+    })
+}
+
 /// Options for configuring the BRK client.
 #[derive(Debug, Clone)]
 pub struct BrkClientOptions {
@@ -1191,6 +1283,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 +1766,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 +3527,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 +3669,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 +3691,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 +7198,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 +7234,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 +7251,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 +7334,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 +7354,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 +8136,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 +8153,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 +8373,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 +8588,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 +9630,7 @@ pub struct BrkClient {
 
 impl BrkClient {
     /// Client version.
-    pub const VERSION: &'static str = "v0.3.0";
+    pub const VERSION: &'static str = "v0.3.6";
 
     /// Create a new client with the given base URL.
     pub fn new(base_url: impl Into<String>) -> Self {
@@ -9007,6 +9684,34 @@ impl BrkClient {
         ))
     }
 
+    /// Decode a mainnet Bitcoin address into the BRK address type and raw payload bytes.
+    pub fn decode_address_payload(address: &str) -> Result<AddressPayload> {
+        decode_address_payload(address)
+    }
+
+    /// Compute the RapidHash v3 hash-prefix for raw address payload bytes.
+    pub fn address_payload_hash_prefix(payload: &[u8], nibbles: usize) -> Result<String> {
+        address_payload_hash_prefix(payload, nibbles)
+    }
+
+    /// Decode a mainnet Bitcoin address and compute its hash prefix.
+    pub fn address_hash_prefix(address: &str, nibbles: usize) -> Result<AddressHashPrefix> {
+        address_hash_prefix(address, nibbles)
+    }
+
+    /// Fetch address hash-prefix matches from raw payload bytes matching `addr_type` length.
+    pub fn get_address_payload_hash_prefix_matches(&self, addr_type: OutputType, payload: &[u8], nibbles: usize) -> Result<AddrHashPrefixMatches> {
+        validate_address_payload_for_type(addr_type, payload)?;
+        let prefix = address_payload_hash_prefix(payload, nibbles)?;
+        self.get_address_hash_prefix_matches(addr_type, &prefix)
+    }
+
+    /// Fetch address hash-prefix matches for a mainnet Bitcoin address.
+    pub fn get_address_hash_prefix_matches_for_address(&self, address: &str, nibbles: usize) -> Result<AddrHashPrefixMatches> {
+        let hashed = address_hash_prefix(address, nibbles)?;
+        self.get_address_hash_prefix_matches(hashed.addr_type, &hashed.prefix)
+    }
+
     /// Health check
     ///
     /// 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`.
@@ -9281,6 +9986,16 @@ impl BrkClient {
         self.base.get_json(&path)
     }
 
+    /// Address hash-prefix matches
+    ///
+    /// Find addresses by address type and by the first 1-16 hex nibbles of RapidHash v3 over the raw address payload bytes. 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> {
+        let addr_type = address_payload_type_path(addr_type)?;
+        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).

crates/brk_client/tests/hash_prefix.rs

@@ -0,0 +1,44 @@
+use brk_client::{
+    BrkClient, OutputType, address_hash_prefix, address_payload_hash_prefix, decode_address_payload,
+};
+
+#[test]
+fn address_payload_hash_prefix_vectors() {
+    let vectors = [
+        (vec![0x4e, 0x73], "58101afa51a1ecfd"),
+        ((0_u8..20).collect::<Vec<_>>(), "c3327ecb8ae1ff23"),
+        ((0_u8..32).collect::<Vec<_>>(), "c0186990f026b180"),
+        ((0_u8..65).collect::<Vec<_>>(), "0d4b77027ae7d700"),
+    ];
+
+    for (payload, expected) in vectors.iter() {
+        assert_eq!(address_payload_hash_prefix(payload, 16).unwrap(), *expected);
+        assert_eq!(
+            BrkClient::address_payload_hash_prefix(payload, 8).unwrap(),
+            &expected[..8]
+        );
+    }
+}
+
+#[test]
+fn address_payload_hash_prefix_validation() {
+    assert!(address_payload_hash_prefix(&[], 16).is_err());
+    assert!(address_payload_hash_prefix(&[0; 66], 16).is_err());
+    assert!(address_payload_hash_prefix(&[1, 2], 0).is_err());
+    assert!(address_payload_hash_prefix(&[1, 2], 17).is_err());
+}
+
+#[test]
+fn address_hash_prefix_uses_brk_address_parser() {
+    let address = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT";
+    let decoded = decode_address_payload(address).unwrap();
+    assert_eq!(decoded.addr_type, OutputType::P2PKH);
+    assert_eq!(decoded.payload.len(), 20);
+
+    let hashed = address_hash_prefix(address, 8).unwrap();
+    assert_eq!(hashed.addr_type, OutputType::P2PKH);
+    assert_eq!(
+        hashed.prefix,
+        address_payload_hash_prefix(&decoded.payload, 8).unwrap()
+    );
+}

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;
@@ -27,7 +27,7 @@ use crate::{
     },
     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/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::{
@@ -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()?;
@@ -436,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");
@@ -474,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,
@@ -486,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/indexes/addr.rs

@@ -250,12 +250,7 @@ impl Vecs {
                 identity: LazyVecFrom1::init(
                     "op_return_index",
                     version,
-                    indexer
-                        .vecs
-                        .scripts
-                        .op_return
-                        .to_tx_index
-                        .read_only_boxed_clone(),
+                    indexer.vecs.op_return.to_tx_index.read_only_boxed_clone(),
                     |index, _| index,
                 ),
             },

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/inputs/by_type/compute.rs

@@ -6,6 +6,8 @@ use vecdb::{AnyVec, Exit, ReadableVec, VecIndex, WritableVec};
 use super::{Vecs, WithInputTypes};
 use crate::internal::{CoinbasePolicy, PerBlockCumulativeRolling, walk_blocks};
 
+const WRITE_INTERVAL: usize = 10_000;
+
 impl Vecs {
     pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
         let starting_lengths = indexer.safe_lengths();
@@ -37,6 +39,7 @@ impl Vecs {
 
             let mut itype_cursor = indexer.vecs.inputs.output_type.cursor();
             let mut fi_in_cursor = indexer.vecs.transactions.first_txin_index.cursor();
+            let mut height = skip;
 
             walk_blocks(
                 &fi_batch,
@@ -65,7 +68,8 @@ impl Vecs {
                     );
                     push_block(&mut self.tx_count, agg.txs_all, &agg.txs_per_type);
 
-                    if self.input_count.all.block.batch_limit_reached() {
+                    height += 1;
+                    if height.is_multiple_of(WRITE_INTERVAL) {
                         let _lock = exit.lock();
                         self.input_count.write()?;
                         self.tx_count.write()?;
@@ -79,12 +83,12 @@ impl Vecs {
                 self.input_count.write()?;
                 self.tx_count.write()?;
             }
-
-            self.input_count
-                .compute_rest(starting_lengths.height, exit)?;
-            self.tx_count.compute_rest(starting_lengths.height, exit)?;
         }
 
+        self.input_count
+            .compute_rest(starting_lengths.height, exit)?;
+        self.tx_count.compute_rest(starting_lengths.height, exit)?;
+
         for (otype, source) in self.input_count.by_type.iter_typed() {
             self.input_share.get_mut(otype).compute_count_ratio(
                 source,

crates/brk_computer/src/inputs/compute.rs

@@ -3,13 +3,12 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, indexes};
+use crate::blocks;
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
         exit: &Exit,
     ) -> Result<()> {
@@ -18,7 +17,7 @@ impl Vecs {
         let starting_lengths = indexer.safe_lengths();
 
         self.spent.compute(indexer, exit)?;
-        self.count.compute(indexer, indexes, blocks, exit)?;
+        self.count.compute(indexer, blocks, exit)?;
         self.per_sec.compute(&self.count, &starting_lengths, exit)?;
         self.by_type.compute(indexer, exit)?;
 

crates/brk_computer/src/inputs/count/compute.rs

@@ -3,27 +3,25 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, indexes};
+use crate::blocks;
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         let starting_height = indexer.safe_lengths().height;
         let window_starts = blocks.lookback.window_starts();
-        self.0.compute(
+
+        self.sum.compute_count_from_indexes(
             starting_height,
-            &indexes.tx_index.input_count,
-            &indexer.vecs.transactions.first_tx_index,
-            &indexes.height.tx_index_count,
-            &window_starts,
+            &indexer.vecs.inputs.first_txin_index,
+            &indexer.vecs.inputs.outpoint,
             exit,
-            0,
         )?;
+        self.compute_rest(starting_height, &window_starts, exit)?;
 
         Ok(())
     }

crates/brk_computer/src/internal/per_block/computed/aggregated.rs

@@ -2,10 +2,7 @@ use brk_error::Result;
 use brk_traversable::Traversable;
 use brk_types::Height;
 use schemars::JsonSchema;
-use vecdb::{
-    AnyStoredVec, AnyVec, Database, EagerVec, Exit, ImportableVec, PcoVec, ReadableVec, Rw,
-    StorageMode, VecIndex, VecValue, Version, WritableVec,
-};
+use vecdb::{Database, EagerVec, Exit, ImportableVec, PcoVec, Rw, StorageMode, Version};
 
 use crate::{
     indexes,
@@ -52,82 +49,19 @@ where
         })
     }
 
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn compute<A>(
+    pub(crate) fn compute_rest(
         &mut self,
         max_from: Height,
-        source: &impl ReadableVec<A, T>,
-        first_indexes: &impl ReadableVec<Height, A>,
-        count_indexes: &impl ReadableVec<Height, brk_types::StoredU64>,
         windows: &WindowStarts<'_>,
         exit: &Exit,
-        skip_count: usize,
     ) -> Result<()>
     where
         T: From<f64> + Default + Copy + Ord,
         f64: From<T>,
-        A: VecIndex + VecValue + brk_types::CheckedSub<A>,
     {
-        let combined_version = source.version() + first_indexes.version() + count_indexes.version();
-
-        let mut index = max_from;
-        index = {
-            self.sum
-                .validate_computed_version_or_reset(combined_version)?;
-            index.min(Height::from(self.sum.len()))
-        };
-        index = {
-            self.cumulative
-                .height
-                .validate_computed_version_or_reset(combined_version)?;
-            index.min(Height::from(self.cumulative.height.len()))
-        };
-
-        let start = index.to_usize();
-
-        self.sum.truncate_if_needed_at(start)?;
-        self.cumulative.height.truncate_if_needed_at(start)?;
-
-        let mut cumulative_val = index.decremented().map_or(T::from(0_usize), |idx| {
-            self.cumulative
-                .height
-                .collect_one_at(idx.to_usize())
-                .unwrap_or(T::from(0_usize))
-        });
-
-        let fi_len = first_indexes.len();
-        let first_indexes_batch: Vec<A> = first_indexes.collect_range_at(start, fi_len);
-        let count_indexes_batch: Vec<brk_types::StoredU64> =
-            count_indexes.collect_range_at(start, fi_len);
-
-        first_indexes_batch
-            .into_iter()
-            .zip(count_indexes_batch)
-            .try_for_each(|(first_index, count_index)| -> Result<()> {
-                let count = u64::from(count_index) as usize;
-                let effective_count = count.saturating_sub(skip_count);
-                let effective_first_index = first_index + skip_count.min(count);
-
-                let efi = effective_first_index.to_usize();
-                let sum_val = source.fold_range_at(
-                    efi,
-                    efi + effective_count,
-                    T::from(0_usize),
-                    |acc, val| acc + val,
-                );
-
-                self.sum.push(sum_val);
-                cumulative_val += sum_val;
-                self.cumulative.height.push(cumulative_val);
-
-                Ok(())
-            })?;
-
-        let _lock = exit.lock();
-        self.sum.write()?;
-        self.cumulative.height.write()?;
-        drop(_lock);
-
+        self.cumulative
+            .height
+            .compute_cumulative(max_from, &self.sum, exit)?;
         self.rolling.compute(max_from, windows, &self.sum, exit)?;
         Ok(())
     }

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/per_tx/lazy_distribution.rs

@@ -3,7 +3,7 @@ use brk_indexer::{Indexer, Lengths};
 use brk_traversable::Traversable;
 use brk_types::TxIndex;
 use schemars::JsonSchema;
-use vecdb::{Database, Exit, LazyVecFrom2, ReadableVec, Rw, StorageMode, Version};
+use vecdb::{Database, Exit, LazyVecFrom1, ReadableVec, Rw, StorageMode, Version};
 
 use crate::{
     indexes,
@@ -11,29 +11,27 @@ use crate::{
 };
 
 #[derive(Traversable)]
-pub struct LazyPerTxDistribution<T, S1, S2, M: StorageMode = Rw>
+pub struct LazyPerTxDistribution<T, S, M: StorageMode = Rw>
 where
     T: ComputedVecValue + PartialOrd + JsonSchema,
-    S1: ComputedVecValue,
-    S2: ComputedVecValue,
+    S: ComputedVecValue,
 {
-    pub tx_index: LazyVecFrom2<TxIndex, T, TxIndex, S1, TxIndex, S2>,
+    pub tx_index: LazyVecFrom1<TxIndex, T, TxIndex, S>,
     #[traversable(flatten)]
     pub distribution: TxDerivedDistribution<T, M>,
 }
 
-impl<T, S1, S2> LazyPerTxDistribution<T, S1, S2>
+impl<T, S> LazyPerTxDistribution<T, S>
 where
     T: NumericValue + JsonSchema,
-    S1: ComputedVecValue + JsonSchema,
-    S2: ComputedVecValue + JsonSchema,
+    S: ComputedVecValue + JsonSchema,
 {
     pub(crate) fn forced_import(
         db: &Database,
         name: &str,
         version: Version,
         indexes: &indexes::Vecs,
-        tx_index: LazyVecFrom2<TxIndex, T, TxIndex, S1, TxIndex, S2>,
+        tx_index: LazyVecFrom1<TxIndex, T, TxIndex, S>,
     ) -> Result<Self> {
         let distribution = TxDerivedDistribution::forced_import(db, name, version, indexes)?;
         Ok(Self {
@@ -52,7 +50,7 @@ where
     where
         T: Copy + Ord + From<f64> + Default,
         f64: From<T>,
-        LazyVecFrom2<TxIndex, T, TxIndex, S1, TxIndex, S2>: ReadableVec<TxIndex, T>,
+        LazyVecFrom1<TxIndex, T, TxIndex, S>: ReadableVec<TxIndex, T>,
     {
         self.distribution
             .derive_from(indexer, indexes, starting_lengths, &self.tx_index, exit)

crates/brk_computer/src/internal/per_tx/lazy_distribution_transformed.rs

@@ -1,36 +1,34 @@
 use brk_traversable::Traversable;
 use brk_types::{TxIndex, Version};
 use schemars::JsonSchema;
-use vecdb::{LazyVecFrom2, UnaryTransform};
+use vecdb::{LazyVecFrom1, UnaryTransform};
 
 use crate::internal::{ComputedVecValue, LazyTxDerivedDistribution, TxDerivedDistribution};
 
 /// Like `LazyPerTxDistribution` but with a lazy-derived distribution
 /// (transformed from another type's distribution rather than eagerly computed).
 #[derive(Clone, Traversable)]
-pub struct LazyPerTxDistributionTransformed<T, S1, S2, DSource>
+pub struct LazyPerTxDistributionTransformed<T, S, DSource>
 where
     T: ComputedVecValue + JsonSchema,
-    S1: ComputedVecValue,
-    S2: ComputedVecValue,
+    S: ComputedVecValue,
     DSource: ComputedVecValue,
 {
-    pub tx_index: LazyVecFrom2<TxIndex, T, TxIndex, S1, TxIndex, S2>,
+    pub tx_index: LazyVecFrom1<TxIndex, T, TxIndex, S>,
     #[traversable(flatten)]
     pub distribution: LazyTxDerivedDistribution<T, DSource>,
 }
 
-impl<T, S1, S2, DSource> LazyPerTxDistributionTransformed<T, S1, S2, DSource>
+impl<T, S, DSource> LazyPerTxDistributionTransformed<T, S, DSource>
 where
     T: ComputedVecValue + JsonSchema + 'static,
-    S1: ComputedVecValue + JsonSchema,
-    S2: ComputedVecValue + JsonSchema,
+    S: ComputedVecValue + JsonSchema,
     DSource: ComputedVecValue + JsonSchema,
 {
     pub(crate) fn new<F: UnaryTransform<DSource, T>>(
         name: &str,
         version: Version,
-        tx_index: LazyVecFrom2<TxIndex, T, TxIndex, S1, TxIndex, S2>,
+        tx_index: LazyVecFrom1<TxIndex, T, TxIndex, S>,
         source_distribution: &TxDerivedDistribution<DSource>,
     ) -> Self {
         let distribution =

crates/brk_computer/src/internal/transform/arithmetic.rs

@@ -146,11 +146,11 @@ impl UnaryTransform<StoredU64, Weight> for VBytesToWeight {
     }
 }
 
-pub struct VSizeToWeight;
+pub struct WeightToVSize;
 
-impl UnaryTransform<VSize, Weight> for VSizeToWeight {
+impl UnaryTransform<Weight, VSize> for WeightToVSize {
     #[inline(always)]
-    fn apply(vsize: VSize) -> Weight {
-        Weight::from(vsize)
+    fn apply(weight: Weight) -> VSize {
+        VSize::from(weight)
     }
 }

crates/brk_computer/src/internal/transform/mod.rs

@@ -8,7 +8,7 @@ mod specialized;
 pub use arithmetic::{
     BlocksToDaysF32, DifficultyToHashF64, HalveCents, HalveDollars, HalveSats, HalveSatsToBitcoin,
     Identity, MaskSats, OneMinusBp16, OneMinusF64, ReturnF32Tenths, ReturnI8, ReturnU16,
-    ThsToPhsF32, VBytesToWeight, VSizeToWeight,
+    ThsToPhsF32, VBytesToWeight, WeightToVSize,
 };
 pub use bps::{
     Bp16ToFloat, Bp16ToPercent, Bp32ToFloat, Bp32ToPercent, Bps16ToFloat, Bps16ToPercent,

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

@@ -20,9 +20,10 @@ mod internal;
 mod investing;
 mod market;
 mod mining;
+mod op_return;
 mod outputs;
 mod pools;
-pub mod prices;
+pub mod price;
 mod supply;
 mod transactions;
 
@@ -38,15 +39,16 @@ 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>>,
     pub inputs: Box<inputs::Vecs<M>>,
     pub outputs: Box<outputs::Vecs<M>>,
+    pub op_return: Box<op_return::Vecs<M>>,
 }
 
-const VERSION: Version = Version::new(6);
+const VERSION: Version = Version::new(7);
 
 impl Computer {
     pub fn forced_import(outputs_path: &Path, indexer: &Indexer) -> Result<Self> {
@@ -66,14 +68,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<_> {
@@ -87,8 +89,9 @@ impl Computer {
 
         let cached_starts = blocks.lookback.cached_window_starts();
 
-        let (inputs, outputs, mining, transactions, pools, cointime) =
-            timed("Imported inputs/outputs/mining/tx/pools/cointime", || {
+        let (inputs, outputs, mining, transactions, pools, cointime, op_return) = timed(
+            "Imported inputs/outputs/mining/tx/pools/cointime/op_return",
+            || {
                 thread::scope(|s| -> Result<_> {
                     let inputs_handle = big_thread().spawn_scoped(s, || -> Result<_> {
                         Ok(Box::new(inputs::Vecs::forced_import(
@@ -143,15 +146,33 @@ impl Computer {
                         &cached_starts,
                     )?);
 
+                    let op_return_handle = big_thread().spawn_scoped(s, || -> Result<_> {
+                        Ok(Box::new(op_return::Vecs::forced_import(
+                            &computed_path,
+                            VERSION,
+                            &indexes,
+                        )?))
+                    })?;
+
                     let inputs = inputs_handle.join().unwrap()?;
                     let outputs = outputs_handle.join().unwrap()?;
                     let mining = mining_handle.join().unwrap()?;
                     let transactions = transactions_handle.join().unwrap()?;
                     let pools = pools_handle.join().unwrap()?;
+                    let op_return = op_return_handle.join().unwrap()?;
 
-                    Ok((inputs, outputs, mining, transactions, pools, cointime))
+                    Ok((
+                        inputs,
+                        outputs,
+                        mining,
+                        transactions,
+                        pools,
+                        cointime,
+                        op_return,
+                    ))
                 })
-            })?;
+            },
+        )?;
 
         // Market, indicators, and distribution are independent; import in parallel.
         // Supply depends on distribution so it runs after.
@@ -223,8 +244,9 @@ impl Computer {
             cointime,
             indexes,
             inputs,
-            prices,
+            price,
             outputs,
+            op_return,
         };
 
         Self::retain_databases(&computed_path)?;
@@ -244,11 +266,12 @@ 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,
             outputs::DB_NAME,
+            op_return::DB_NAME,
         ];
 
         if !computed_path.exists() {
@@ -292,13 +315,12 @@ impl Computer {
             let (inputs_result, prices_result) = rayon::join(
                 || {
                     timed("Computed inputs", || {
-                        self.inputs
-                            .compute(indexer, &self.indexes, &self.blocks, exit)
+                        self.inputs.compute(indexer, &self.blocks, exit)
                     })
                 },
                 || {
-                    timed("Computed prices", || {
-                        self.prices.compute(indexer, &self.indexes, exit)
+                    timed("Computed price", || {
+                        self.price.compute(indexer, &self.indexes, exit)
                     })
                 },
             );
@@ -310,7 +332,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 +343,7 @@ impl Computer {
                         &self.indexes,
                         &self.blocks,
                         &self.inputs,
-                        &self.prices,
+                        &self.price,
                         exit,
                     )
                 })?;
@@ -331,24 +353,25 @@ impl Computer {
                         &self.indexes,
                         &self.blocks,
                         &self.transactions,
-                        &self.prices,
+                        &self.price,
                         exit,
                     )
                 })
             });
 
+            let op_return = scope.spawn(|| {
+                timed("Computed OP_RETURN", || {
+                    self.op_return.compute(indexer, exit)
+                })
+            });
+
             timed("Computed outputs", || {
-                self.outputs.compute(
-                    indexer,
-                    &self.indexes,
-                    &self.inputs,
-                    &self.blocks,
-                    &self.prices,
-                    exit,
-                )
+                self.outputs
+                    .compute(indexer, &self.inputs, &self.blocks, &self.price, exit)
             })?;
 
             tx_mining.join().unwrap()?;
+            op_return.join().unwrap()?;
             market.join().unwrap()?;
             Ok(())
         })?;
@@ -360,7 +383,7 @@ impl Computer {
                         indexer,
                         &self.indexes,
                         &self.blocks,
-                        &self.prices,
+                        &self.price,
                         &self.mining,
                         exit,
                     )
@@ -372,7 +395,7 @@ impl Computer {
                     self.investing.compute(
                         indexer,
                         &self.indexes,
-                        &self.prices,
+                        &self.price,
                         &self.blocks,
                         &self.market.lookback,
                         exit,
@@ -388,7 +411,7 @@ impl Computer {
                     &self.outputs,
                     &self.transactions,
                     &self.blocks,
-                    &self.prices,
+                    &self.price,
                     exit,
                 )
             })?;
@@ -421,7 +444,7 @@ impl Computer {
                     &self.blocks,
                     &self.mining,
                     &self.transactions,
-                    &self.prices,
+                    &self.price,
                     &self.distribution,
                     exit,
                 )
@@ -430,7 +453,7 @@ impl Computer {
             timed("Computed cointime", || {
                 self.cointime.compute(
                     indexer,
-                    &self.prices,
+                    &self.price,
                     &self.blocks,
                     &self.mining,
                     &self.supply,
@@ -445,7 +468,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,11 +521,12 @@ impl_iter_named!(
     investing,
     market,
     pools,
-    prices,
+    price,
     distribution,
     supply,
     inputs,
-    outputs
+    outputs,
+    op_return
 );
 
 fn timed<T>(label: &str, f: impl FnOnce() -> T) -> T {

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/op_return/by_kind.rs

@@ -0,0 +1,89 @@
+use brk_traversable::Traversable;
+use brk_types::OpReturnKind;
+
+macro_rules! define_by_kind {
+    ($($field:ident => $kind:ident),+ $(,)?) => {
+        #[derive(Traversable)]
+        pub struct ByKind<T> {
+            $(pub $field: T),+
+        }
+
+        impl<T> ByKind<T> {
+            pub fn try_new<E>(
+                mut create: impl FnMut(OpReturnKind, &'static str) -> Result<T, E>,
+            ) -> Result<Self, E> {
+                Ok(Self {
+                    $($field: create(OpReturnKind::$kind, stringify!($field))?),+
+                })
+            }
+
+            pub fn iter(&self) -> impl Iterator<Item = &T> {
+                [$( &self.$field ),+].into_iter()
+            }
+
+            pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
+                let Self { $($field),+ } = self;
+                [$($field),+].into_iter()
+            }
+
+            pub fn iter_typed(&self) -> impl Iterator<Item = (OpReturnKind, &T)> {
+                [$( (OpReturnKind::$kind, &self.$field) ),+].into_iter()
+            }
+
+            pub fn iter_typed_mut(
+                &mut self,
+            ) -> impl Iterator<Item = (OpReturnKind, &mut T)> {
+                let Self { $($field),+ } = self;
+                [$( (OpReturnKind::$kind, $field) ),+].into_iter()
+            }
+        }
+    };
+}
+
+define_by_kind! {
+    runes => Runes,
+    veri_block => VeriBlock,
+    omni => Omni,
+    stacks => Stacks,
+    blockstack => Blockstack,
+    colu => Colu,
+    open_assets => OpenAssets,
+    komodo => Komodo,
+    coin_spark => CoinSpark,
+    poet => Poet,
+    docproof => Docproof,
+    open_timestamps => OpenTimestamps,
+    factom => Factom,
+    eternity_wall => EternityWall,
+    memo => Memo,
+    bitproof => Bitproof,
+    ascribe => Ascribe,
+    stampery => Stampery,
+    epobc => Epobc,
+    bare_hash => BareHash,
+    text => Text,
+    empty => Empty,
+    unknown => Unknown,
+}
+
+#[cfg(test)]
+mod tests {
+    use std::convert::Infallible;
+
+    use brk_types::OpReturnKind;
+
+    use super::ByKind;
+
+    #[test]
+    fn covers_every_kind_in_discriminant_order() {
+        let by_kind =
+            ByKind::try_new(|kind, _| Ok::<_, Infallible>(kind)).expect("infallible constructor");
+        let kinds: Vec<_> = by_kind.iter_typed().collect();
+
+        assert_eq!(kinds.len(), OpReturnKind::Unknown as usize + 1);
+        for (index, (kind, value)) in kinds.into_iter().enumerate() {
+            assert_eq!(kind as usize, index);
+            assert_eq!(kind, *value);
+        }
+    }
+}

crates/brk_computer/src/op_return/compute.rs

@@ -0,0 +1,242 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_types::{OpReturnKind, VSize};
+use vecdb::{AnyVec, Exit, ReadableVec, VecIndex};
+
+use super::{Vecs, vecs::Totals};
+
+const KIND_COUNT: usize = OpReturnKind::Unknown as usize + 1;
+const OLD_STANDARD_MAX_POST_OP_RETURN_BYTES: u64 = 82;
+const WRITE_INTERVAL: usize = 10_000;
+
+#[derive(Clone, Copy, Default)]
+struct PolicyTotals {
+    oversized: Totals,
+    multiple: Totals,
+    pre_v30_nonstandard: Totals,
+}
+
+#[derive(Clone, Copy, Default)]
+struct Carrier {
+    kinds: u32,
+    output_count: u64,
+    post_op_return_bytes: u64,
+    oversized_output_count: u64,
+    oversized_post_op_return_bytes: u64,
+    vsize: VSize,
+}
+
+impl Carrier {
+    fn add_output(&mut self, kind: OpReturnKind, post_op_return_bytes: u64) {
+        self.kinds |= kind_bit(kind);
+        self.output_count += 1;
+        self.post_op_return_bytes += post_op_return_bytes;
+        if post_op_return_bytes > OLD_STANDARD_MAX_POST_OP_RETURN_BYTES {
+            self.oversized_output_count += 1;
+            self.oversized_post_op_return_bytes += post_op_return_bytes;
+        }
+    }
+}
+
+impl Vecs {
+    pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
+        self.db.sync_bg_tasks()?;
+
+        let starting_lengths = indexer.safe_lengths();
+        let raw = &indexer.vecs.op_return;
+        let txs = &indexer.vecs.transactions;
+        let version = raw.first_index.version()
+            + raw.to_tx_index.version()
+            + raw.kind.version()
+            + raw.post_op_return_bytes.version()
+            + txs.weight.version();
+
+        self.validate_and_truncate(version, starting_lengths.height)?;
+
+        let skip = self.min_len();
+        let end = raw
+            .first_index
+            .len()
+            .min(starting_lengths.height.to_usize());
+        if skip < end {
+            self.truncate_if_needed_at(skip)?;
+
+            let op_return_len = raw
+                .to_tx_index
+                .len()
+                .min(raw.kind.len())
+                .min(raw.post_op_return_bytes.len())
+                .min(starting_lengths.op_return_index.to_usize());
+            let mut tx_cursor = raw.to_tx_index.cursor();
+            let mut kind_cursor = raw.kind.cursor();
+            let mut post_op_return_bytes = raw.post_op_return_bytes.cursor();
+            let mut first_index_cursor = raw.first_index.cursor();
+            let mut weight_cursor = txs.weight.cursor();
+            first_index_cursor.advance(skip);
+            let mut start = first_index_cursor.next().unwrap().to_usize();
+
+            for height in skip..end {
+                let block_end = if height + 1 < end {
+                    first_index_cursor.next().unwrap().to_usize()
+                } else {
+                    op_return_len
+                };
+
+                tx_cursor.advance(start - tx_cursor.position());
+                kind_cursor.advance(start - kind_cursor.position());
+                post_op_return_bytes.advance(start - post_op_return_bytes.position());
+
+                let mut total = Totals::default();
+                let mut by_kind = [Totals::default(); KIND_COUNT];
+                let mut policy = PolicyTotals::default();
+                let mut current_tx = None;
+                let mut carrier = Carrier::default();
+
+                for _ in start..block_end {
+                    let tx_index = tx_cursor.next().unwrap();
+                    let kind = kind_cursor.next().unwrap();
+                    let bytes = u32::from(post_op_return_bytes.next().unwrap()) as u64;
+                    let kind_index = kind as usize;
+
+                    if current_tx != Some(tx_index) {
+                        finalize_transaction(&mut total, &mut by_kind, &mut policy, carrier);
+                        current_tx = Some(tx_index);
+                        carrier = Carrier::default();
+
+                        let tx_position = tx_index.to_usize();
+                        weight_cursor.advance(tx_position - weight_cursor.position());
+                        carrier.vsize = VSize::from(weight_cursor.next().unwrap());
+                    }
+
+                    total.output_count += 1;
+                    total.post_op_return_bytes += bytes;
+                    by_kind[kind_index].output_count += 1;
+                    by_kind[kind_index].post_op_return_bytes += bytes;
+                    carrier.add_output(kind, bytes);
+                }
+
+                finalize_transaction(&mut total, &mut by_kind, &mut policy, carrier);
+
+                self.total.push(total);
+                for (kind, metrics) in self.by_kind.iter_typed_mut() {
+                    metrics.push(by_kind[kind as usize]);
+                }
+                self.policy.oversized.push(policy.oversized);
+                self.policy.multiple.push(policy.multiple);
+                self.policy
+                    .pre_v30_nonstandard
+                    .push(policy.pre_v30_nonstandard);
+
+                if (height + 1).is_multiple_of(WRITE_INTERVAL) {
+                    let _lock = exit.lock();
+                    self.write()?;
+                }
+                start = block_end;
+            }
+
+            let _lock = exit.lock();
+            self.write()?;
+        }
+
+        self.compute_cumulative(starting_lengths.height, exit)?;
+
+        let exit = exit.clone();
+        self.db.run_bg(move |db| {
+            let _lock = exit.lock();
+            db.compact_deferred_default()
+        });
+        Ok(())
+    }
+}
+
+fn finalize_transaction(
+    total: &mut Totals,
+    by_kind: &mut [Totals; KIND_COUNT],
+    policy: &mut PolicyTotals,
+    carrier: Carrier,
+) {
+    if carrier.output_count == 0 {
+        return;
+    }
+
+    add_carrier(total, carrier.vsize);
+    let mut kinds = carrier.kinds;
+    while kinds != 0 {
+        let kind_index = kinds.trailing_zeros() as usize;
+        add_carrier(&mut by_kind[kind_index], carrier.vsize);
+        kinds &= kinds - 1;
+    }
+
+    if carrier.oversized_output_count > 0 {
+        policy.oversized.output_count += carrier.oversized_output_count;
+        policy.oversized.post_op_return_bytes += carrier.oversized_post_op_return_bytes;
+        add_carrier(&mut policy.oversized, carrier.vsize);
+    }
+
+    if carrier.output_count > 1 {
+        policy.multiple.output_count += carrier.output_count;
+        policy.multiple.post_op_return_bytes += carrier.post_op_return_bytes;
+        add_carrier(&mut policy.multiple, carrier.vsize);
+    }
+
+    if carrier.oversized_output_count > 0 || carrier.output_count > 1 {
+        policy.pre_v30_nonstandard.output_count += carrier.output_count;
+        policy.pre_v30_nonstandard.post_op_return_bytes += carrier.post_op_return_bytes;
+        add_carrier(&mut policy.pre_v30_nonstandard, carrier.vsize);
+    }
+}
+
+fn add_carrier(metrics: &mut Totals, vsize: VSize) {
+    metrics.carrier_tx_count += 1;
+    metrics.carrier_vsize += vsize;
+}
+
+const fn kind_bit(kind: OpReturnKind) -> u32 {
+    1_u32 << kind as u8
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn multiple_kinds_count_one_total_carrier() {
+        let mut total = Totals::default();
+        let mut by_kind = [Totals::default(); KIND_COUNT];
+        let mut policy = PolicyTotals::default();
+        let mut carrier = Carrier {
+            vsize: VSize::new(100),
+            ..Carrier::default()
+        };
+        carrier.add_output(OpReturnKind::Runes, 15);
+        carrier.add_output(OpReturnKind::Omni, 15);
+
+        finalize_transaction(&mut total, &mut by_kind, &mut policy, carrier);
+
+        assert_eq!(total.carrier_tx_count, 1);
+        assert_eq!(by_kind[OpReturnKind::Runes as usize].carrier_tx_count, 1);
+        assert_eq!(by_kind[OpReturnKind::Omni as usize].carrier_tx_count, 1);
+        assert_eq!(policy.multiple.output_count, 2);
+        assert_eq!(policy.pre_v30_nonstandard.carrier_tx_count, 1);
+        assert_eq!(policy.oversized.carrier_tx_count, 0);
+    }
+
+    #[test]
+    fn oversized_output_marks_pre_v30_nonstandard_once() {
+        let mut total = Totals::default();
+        let mut by_kind = [Totals::default(); KIND_COUNT];
+        let mut policy = PolicyTotals::default();
+        let mut carrier = Carrier {
+            vsize: VSize::new(120),
+            ..Carrier::default()
+        };
+        carrier.add_output(OpReturnKind::Unknown, 83);
+
+        finalize_transaction(&mut total, &mut by_kind, &mut policy, carrier);
+
+        assert_eq!(policy.oversized.output_count, 1);
+        assert_eq!(policy.oversized.carrier_vsize, VSize::new(120));
+        assert_eq!(policy.pre_v30_nonstandard.carrier_tx_count, 1);
+        assert_eq!(policy.multiple.carrier_tx_count, 0);
+    }
+}

crates/brk_computer/src/op_return/import.rs

@@ -0,0 +1,34 @@
+use std::path::Path;
+
+use brk_error::Result;
+use brk_types::Version;
+
+use super::{ByKind, Metrics, Policy, Vecs};
+use crate::{
+    indexes,
+    internal::db_utils::{finalize_db, open_db},
+};
+
+impl Vecs {
+    pub(crate) fn forced_import(
+        parent_path: &Path,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let db = open_db(parent_path, super::DB_NAME, 1_000_000)?;
+        let total = Metrics::forced_import(&db, "op_return", version, indexes)?;
+        let by_kind = ByKind::try_new(|_, name| {
+            Metrics::forced_import(&db, &format!("op_return_{name}"), version, indexes)
+        })?;
+        let policy = Policy::forced_import(&db, version, indexes)?;
+
+        let this = Self {
+            db,
+            total,
+            by_kind,
+            policy,
+        };
+        finalize_db(&this.db, &this)?;
+        Ok(this)
+    }
+}

crates/brk_computer/src/op_return/mod.rs

@@ -0,0 +1,9 @@
+mod by_kind;
+mod compute;
+mod import;
+mod vecs;
+
+pub use by_kind::ByKind;
+pub use vecs::{Metrics, Policy, Vecs};
+
+pub const DB_NAME: &str = "op_return";

crates/brk_computer/src/op_return/vecs.rs

@@ -0,0 +1,274 @@
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Height, StoredU64, VSize, Version};
+use schemars::JsonSchema;
+use vecdb::{
+    AnyStoredVec, AnyVec, Database, EagerVec, Exit, ImportableVec, PcoVec, Rw, StorageMode,
+    WritableVec,
+};
+
+use super::ByKind;
+use crate::{
+    indexes,
+    internal::{NumericValue, PerBlock},
+};
+
+#[derive(Traversable)]
+pub struct Series<T, M: StorageMode = Rw>
+where
+    T: NumericValue + JsonSchema,
+{
+    pub block: M::Stored<EagerVec<PcoVec<Height, T>>>,
+    pub cumulative: PerBlock<T, M>,
+}
+
+impl<T> Series<T>
+where
+    T: NumericValue + JsonSchema,
+{
+    fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let block = EagerVec::forced_import(db, name, version)?;
+        let cumulative =
+            PerBlock::forced_import(db, &format!("{name}_cumulative"), version, indexes)?;
+        Ok(Self { block, cumulative })
+    }
+
+    fn len(&self) -> usize {
+        self.block.len()
+    }
+
+    fn validate_and_truncate(&mut self, version: Version, height: Height) -> Result<()> {
+        self.block.validate_and_truncate(version, height)?;
+        Ok(())
+    }
+
+    fn truncate_if_needed_at(&mut self, len: usize) -> Result<()> {
+        self.block.truncate_if_needed_at(len)?;
+        Ok(())
+    }
+
+    fn push(&mut self, block: T) {
+        self.block.push(block);
+    }
+
+    fn write(&mut self) -> Result<()> {
+        self.block.write()?;
+        Ok(())
+    }
+
+    fn compute_cumulative(&mut self, max_from: Height, exit: &Exit) -> Result<()> {
+        self.cumulative
+            .height
+            .compute_cumulative(max_from, &self.block, exit)?;
+        Ok(())
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+pub(super) struct Totals {
+    pub output_count: u64,
+    pub post_op_return_bytes: u64,
+    pub carrier_tx_count: u64,
+    pub carrier_vsize: VSize,
+}
+
+#[derive(Traversable)]
+pub struct Metrics<M: StorageMode = Rw> {
+    pub output_count: Series<StoredU64, M>,
+    pub post_op_return_bytes: Series<StoredU64, M>,
+    pub carrier_tx_count: Series<StoredU64, M>,
+    pub carrier_vsize: Series<VSize, M>,
+}
+
+impl Metrics {
+    pub(crate) fn forced_import(
+        db: &Database,
+        prefix: &str,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self {
+            output_count: Series::forced_import(
+                db,
+                &format!("{prefix}_output_count"),
+                version,
+                indexes,
+            )?,
+            post_op_return_bytes: Series::forced_import(
+                db,
+                &format!("{prefix}_post_op_return_bytes"),
+                version,
+                indexes,
+            )?,
+            carrier_tx_count: Series::forced_import(
+                db,
+                &format!("{prefix}_carrier_tx_count"),
+                version,
+                indexes,
+            )?,
+            carrier_vsize: Series::forced_import(
+                db,
+                &format!("{prefix}_carrier_vsize"),
+                version,
+                indexes,
+            )?,
+        })
+    }
+
+    fn len(&self) -> usize {
+        self.output_count
+            .len()
+            .min(self.post_op_return_bytes.len())
+            .min(self.carrier_tx_count.len())
+            .min(self.carrier_vsize.len())
+    }
+
+    pub(super) fn push(&mut self, block: Totals) {
+        self.output_count.push(block.output_count.into());
+        self.post_op_return_bytes
+            .push(block.post_op_return_bytes.into());
+        self.carrier_tx_count.push(block.carrier_tx_count.into());
+        self.carrier_vsize.push(block.carrier_vsize);
+    }
+
+    fn validate_and_truncate(&mut self, version: Version, height: Height) -> Result<()> {
+        self.output_count.validate_and_truncate(version, height)?;
+        self.post_op_return_bytes
+            .validate_and_truncate(version, height)?;
+        self.carrier_tx_count
+            .validate_and_truncate(version, height)?;
+        self.carrier_vsize.validate_and_truncate(version, height)?;
+        Ok(())
+    }
+
+    fn truncate_if_needed_at(&mut self, len: usize) -> Result<()> {
+        self.output_count.truncate_if_needed_at(len)?;
+        self.post_op_return_bytes.truncate_if_needed_at(len)?;
+        self.carrier_tx_count.truncate_if_needed_at(len)?;
+        self.carrier_vsize.truncate_if_needed_at(len)?;
+        Ok(())
+    }
+
+    fn write(&mut self) -> Result<()> {
+        self.output_count.write()?;
+        self.post_op_return_bytes.write()?;
+        self.carrier_tx_count.write()?;
+        self.carrier_vsize.write()?;
+        Ok(())
+    }
+
+    fn compute_cumulative(&mut self, max_from: Height, exit: &Exit) -> Result<()> {
+        self.output_count.compute_cumulative(max_from, exit)?;
+        self.post_op_return_bytes
+            .compute_cumulative(max_from, exit)?;
+        self.carrier_tx_count.compute_cumulative(max_from, exit)?;
+        self.carrier_vsize.compute_cumulative(max_from, exit)?;
+        Ok(())
+    }
+}
+
+#[derive(Traversable)]
+pub struct Policy<M: StorageMode = Rw> {
+    pub oversized: Metrics<M>,
+    pub multiple: Metrics<M>,
+    pub pre_v30_nonstandard: Metrics<M>,
+}
+
+impl Policy {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let import = |name| {
+            Metrics::forced_import(db, &format!("op_return_policy_{name}"), version, indexes)
+        };
+
+        Ok(Self {
+            oversized: import("oversized")?,
+            multiple: import("multiple")?,
+            pre_v30_nonstandard: import("pre_v30_nonstandard")?,
+        })
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &Metrics> {
+        [&self.oversized, &self.multiple, &self.pre_v30_nonstandard].into_iter()
+    }
+
+    fn iter_mut(&mut self) -> impl Iterator<Item = &mut Metrics> {
+        [
+            &mut self.oversized,
+            &mut self.multiple,
+            &mut self.pre_v30_nonstandard,
+        ]
+        .into_iter()
+    }
+}
+
+#[derive(Traversable)]
+pub struct Vecs<M: StorageMode = Rw> {
+    #[traversable(skip)]
+    pub(crate) db: Database,
+    pub total: Metrics<M>,
+    pub by_kind: ByKind<Metrics<M>>,
+    pub policy: Policy<M>,
+}
+
+impl Vecs {
+    pub(crate) fn min_len(&self) -> usize {
+        self.by_kind
+            .iter()
+            .chain(self.policy.iter())
+            .map(Metrics::len)
+            .fold(self.total.len(), usize::min)
+    }
+
+    pub(crate) fn validate_and_truncate(&mut self, version: Version, height: Height) -> Result<()> {
+        self.total.validate_and_truncate(version, height)?;
+        for metrics in self.by_kind.iter_mut() {
+            metrics.validate_and_truncate(version, height)?;
+        }
+        for metrics in self.policy.iter_mut() {
+            metrics.validate_and_truncate(version, height)?;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn truncate_if_needed_at(&mut self, len: usize) -> Result<()> {
+        self.total.truncate_if_needed_at(len)?;
+        for metrics in self.by_kind.iter_mut() {
+            metrics.truncate_if_needed_at(len)?;
+        }
+        for metrics in self.policy.iter_mut() {
+            metrics.truncate_if_needed_at(len)?;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn write(&mut self) -> Result<()> {
+        self.total.write()?;
+        for metrics in self.by_kind.iter_mut() {
+            metrics.write()?;
+        }
+        for metrics in self.policy.iter_mut() {
+            metrics.write()?;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn compute_cumulative(&mut self, max_from: Height, exit: &Exit) -> Result<()> {
+        self.total.compute_cumulative(max_from, exit)?;
+        for metrics in self.by_kind.iter_mut() {
+            metrics.compute_cumulative(max_from, exit)?;
+        }
+        for metrics in self.policy.iter_mut() {
+            metrics.compute_cumulative(max_from, exit)?;
+        }
+        Ok(())
+    }
+}

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

@@ -6,6 +6,8 @@ use vecdb::{AnyStoredVec, AnyVec, Exit, ReadableVec, VecIndex, WritableVec};
 use super::{Vecs, WithOutputTypes};
 use crate::internal::{CoinbasePolicy, PerBlockCumulativeRolling, walk_blocks};
 
+const WRITE_INTERVAL: usize = 10_000;
+
 impl Vecs {
     pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
         let starting_lengths = indexer.safe_lengths();
@@ -44,6 +46,7 @@ impl Vecs {
 
             let mut otype_cursor = indexer.vecs.outputs.output_type.cursor();
             let mut fo_cursor = indexer.vecs.transactions.first_txout_index.cursor();
+            let mut height = skip;
 
             walk_blocks(
                 &fi_batch,
@@ -77,7 +80,8 @@ impl Vecs {
                         .block
                         .push(StoredU64::from(spendable_total));
 
-                    if self.output_count.all.block.batch_limit_reached() {
+                    height += 1;
+                    if height.is_multiple_of(WRITE_INTERVAL) {
                         let _lock = exit.lock();
                         self.output_count.write()?;
                         self.spendable_output_count.block.write()?;
@@ -93,14 +97,14 @@ impl Vecs {
                 self.spendable_output_count.block.write()?;
                 self.tx_count.write()?;
             }
-
-            self.output_count
-                .compute_rest(starting_lengths.height, exit)?;
-            self.spendable_output_count
-                .compute_rest(starting_lengths.height, exit)?;
-            self.tx_count.compute_rest(starting_lengths.height, exit)?;
         }
 
+        self.output_count
+            .compute_rest(starting_lengths.height, exit)?;
+        self.spendable_output_count
+            .compute_rest(starting_lengths.height, exit)?;
+        self.tx_count.compute_rest(starting_lengths.height, exit)?;
+
         for (otype, source) in self.output_count.by_type.iter_typed() {
             self.output_share.get_mut(otype).compute_count_ratio(
                 source,

crates/brk_computer/src/outputs/compute.rs

@@ -3,24 +3,23 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, indexes, inputs, prices};
+use crate::{blocks, inputs, price};
 
 impl Vecs {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        indexes: &indexes::Vecs,
         inputs: &inputs::Vecs,
         blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
+        prices: &price::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         self.db.sync_bg_tasks()?;
 
         let starting_lengths = indexer.safe_lengths();
 
-        self.count.compute(indexer, indexes, blocks, exit)?;
+        self.count.compute(indexer, blocks, exit)?;
         self.per_sec.compute(&self.count, &starting_lengths, exit)?;
         self.value.compute(indexer, prices, exit)?;
         self.by_type.compute(indexer, exit)?;

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

@@ -3,27 +3,26 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{blocks, indexes};
+use crate::blocks;
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
-        indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
         exit: &Exit,
     ) -> Result<()> {
         let starting_height = indexer.safe_lengths().height;
         let window_starts = blocks.lookback.window_starts();
-        self.total.compute(
+
+        self.total.sum.compute_count_from_indexes(
             starting_height,
-            &indexes.tx_index.output_count,
-            &indexer.vecs.transactions.first_tx_index,
-            &indexes.height.tx_index_count,
-            &window_starts,
+            &indexer.vecs.outputs.first_txout_index,
+            &indexer.vecs.outputs.value,
             exit,
-            0,
         )?;
+        self.total
+            .compute_rest(starting_height, &window_starts, exit)?;
         Ok(())
     }
 }