release: v0.0.34

.github/workflows/release.yml

@@ -47,7 +47,7 @@ on:
 jobs:
   # Run 'dist plan' (or host) to determine what tasks we need to do
   plan:
-    runs-on: "ubuntu-20.04"
+    runs-on: "ubuntu-latest"
     outputs:
       val: ${{ steps.plan.outputs.manifest }}
       tag: ${{ !github.event.pull_request && github.ref_name || '' }}
@@ -168,7 +168,7 @@ jobs:
     needs:
       - plan
       - build-local-artifacts
-    runs-on: "ubuntu-20.04"
+    runs-on: "ubuntu-latest"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
@@ -218,7 +218,7 @@ jobs:
     if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    runs-on: "ubuntu-20.04"
+    runs-on: "ubuntu-latest"
     outputs:
       val: ${{ steps.host.outputs.manifest }}
     steps:
@@ -282,7 +282,7 @@ jobs:
     # still allowing individual publish jobs to skip themselves (for prereleases).
     # "host" however must run to completion, no skipping allowed!
     if: ${{ always() && needs.host.result == 'success' }}
-    runs-on: "ubuntu-20.04"
+    runs-on: "ubuntu-latest"
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:

.gitignore

@@ -33,6 +33,5 @@ paths.d.ts
 # Outputs
 _outputs
 
-
 # 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.0.23"
+package.version = "0.0.34"
 package.repository = "https://github.com/bitcoinresearchkit/brk"
 
 [profile.release]
@@ -16,7 +16,7 @@ panic = "abort"
 inherits = "release"
 
 [workspace.dependencies]
-axum = "0.8.3"
+axum = "0.8.4"
 bitcoin = { version = "0.32.5", features = ["serde"] }
 bitcoincore-rpc = "0.19.0"
 brk_cli = { version = "0", path = "crates/brk_cli" }
@@ -31,18 +31,21 @@ brk_query = { version = "0", path = "crates/brk_query" }
 brk_server = { version = "0", path = "crates/brk_server" }
 brk_vec = { version = "0", path = "crates/brk_vec" }
 byteview = "0.6.1"
-clap = { version = "4.5.36", features = ["derive", "string"] }
-color-eyre = "0.6.3"
+clap = { version = "4.5.37", features = ["string"] }
+clap_derive = "4.5.32"
+color-eyre = "0.6.4"
 derive_deref = "1.1.1"
-fjall = "2.8.0"
-jiff = "0.2.8"
+fjall = "2.10.0"
+jiff = "0.2.13"
 log = { version = "0.4.27" }
 minreq = { version = "2.13.4", features = ["https", "serde_json"] }
 rayon = "1.10.0"
-serde = { version = "1.0.219", features = ["derive"] }
+serde = { version = "1.0.219" }
+serde_derive = "1.0.219"
 serde_json = { version = "1.0.140", features = ["float_roundtrip"] }
-tabled = "0.18.0"
-zerocopy = { version = "0.8.24", features = ["derive"] }
+tabled = "0.19.0"
+zerocopy = { version = "0.8.25" }
+zerocopy-derive = "0.8.25"
 
 [workspace.metadata.release]
 shared-version = true
@@ -60,3 +63,11 @@ targets = [
     "x86_64-apple-darwin",
     "x86_64-unknown-linux-gnu",
 ]
+
+[workspace.metadata.dist.github-custom-runners]
+global = "ubuntu-latest"
+aarch64-apple-darwin.runner = "macos-14"
+x86_64-unknown-linux-gnu.runner = "ubuntu-latest"
+x86_64-unknown-linux-gnu.container = { image = "quay.io/pypa/manylinux_2_28_x86_64", host = "x86_64-unknown-linux-musl" }
+aarch64-unknown-linux-gnu.runner = "ubuntu-latest"
+aarch64-unknown-linux-gnu.container = { image = "quay.io/pypa/manylinux_2_28_x86_64", host = "x86_64-unknown-linux-musl" }

README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>
@@ -92,8 +92,11 @@ Heartfelt thanks go out to every donor on [Nostr](https://primal.net/p/npub1jagm
 If you'd like to have your own instance hosted for you please contact [hosting@bitcoinresearchkit.org](mailto:hosting@bitcoinresearchkit.org).
 
 - 2 separate dedicated servers (1 GB/s each) with different ISPs and Cloudflare integration for enhanced performance and optimal availability
-- Direct communication for feature requests and support
+- 99.9% SLA
+- Configurated for speed (`raw + eager`)
 - Updates delivered at your convenience
+- Direct communication for feature requests and support
+- Bitcoin Core or Knots with desired version
 - Optional subdomains: `*.bitcoinresearchkit.org`, `*.kibo.money` and `*.satonomics.xyz`
 - Logo featured in the Readme if desired
 

crates/brk_cli/Cargo.toml

@@ -16,12 +16,14 @@ brk_logger = { workspace = true }
 brk_parser = { workspace = true }
 brk_query = { workspace = true }
 brk_server = { workspace = true }
-clap = { workspace = true, features = ["string"] }
+brk_vec = { workspace = true }
+clap = { workspace = true }
+clap_derive = { workspace = true }
 color-eyre = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true }
 tabled = { workspace = true }
-toml = "0.8.20"
+toml = "0.8.22"
 
 [[bin]]
 name = "brk"

crates/brk_cli/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_cli/src/lib.rs

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

crates/brk_cli/src/query.rs

@@ -10,11 +10,11 @@ pub fn query(params: QueryParams) -> color_eyre::Result<()> {
 
     let compressed = config.compressed();
 
-    let mut indexer = Indexer::new(config.indexeddir(), compressed, config.check_collisions())?;
+    let mut indexer = Indexer::new(&config.outputsdir(), compressed, config.check_collisions())?;
     indexer.import_vecs()?;
 
-    let mut computer = Computer::new(config.computeddir(), config.fetcher(), compressed);
-    computer.import_vecs()?;
+    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), compressed);
+    computer.import_vecs(&indexer, config.computation())?;
 
     let query = Query::build(&indexer, &computer);
 

crates/brk_cli/src/run.rs

@@ -12,7 +12,8 @@ use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
 use brk_parser::rpc::{self, Auth, Client, RpcApi};
 use brk_server::{Server, Website, tokio};
-use clap::{Parser, ValueEnum};
+use brk_vec::Computation;
+use clap_derive::{Parser, ValueEnum};
 use color_eyre::eyre::eyre;
 use log::info;
 use serde::{Deserialize, Serialize};
@@ -28,13 +29,13 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
 
     let compressed = config.compressed();
 
-    let mut indexer = Indexer::new(config.indexeddir(), compressed, config.check_collisions())?;
+    let mut indexer = Indexer::new(&config.outputsdir(), compressed, config.check_collisions())?;
     indexer.import_stores()?;
     indexer.import_vecs()?;
 
-    let mut computer = Computer::new(config.computeddir(), config.fetcher(), compressed);
-    computer.import_stores()?;
-    computer.import_vecs()?;
+    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), compressed);
+    computer.import_stores(&indexer)?;
+    computer.import_vecs(&indexer, config.computation())?;
 
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()
@@ -123,6 +124,10 @@ pub struct RunConfig {
     #[arg(short, long)]
     mode: Option<Mode>,
 
+    /// Computation mode for compatible datasets, `lazy` computes data whenever requested without saving it, `eager` computes the data once and saves it to disk, default: Lazy, saved
+    #[arg(short = 'C', long)]
+    computation: Option<Computation>,
+
     /// Activate compression of datasets, set to true to save disk space or false if prioritize speed, default: true, saved
     #[arg(short, long, value_name = "BOOL")]
     compressed: Option<bool>,
@@ -357,18 +362,10 @@ impl RunConfig {
             .map_or_else(default_brk_path, |s| Self::fix_user_path(s.as_ref()))
     }
 
-    fn outputsdir(&self) -> PathBuf {
+    pub fn outputsdir(&self) -> PathBuf {
         self.brkdir().join("outputs")
     }
 
-    pub fn indexeddir(&self) -> PathBuf {
-        self.outputsdir().join("indexed")
-    }
-
-    pub fn computeddir(&self) -> PathBuf {
-        self.outputsdir().join("computed")
-    }
-
     pub fn harsdir(&self) -> PathBuf {
         self.outputsdir().join("hars")
     }
@@ -421,6 +418,10 @@ impl RunConfig {
             .then(|| Fetcher::import(Some(self.harsdir().as_path())).unwrap())
     }
 
+    pub fn computation(&self) -> Computation {
+        self.computation.unwrap_or_default()
+    }
+
     pub fn compressed(&self) -> bool {
         self.compressed.is_none_or(|b| b)
     }

crates/brk_computer/Cargo.toml

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

crates/brk_computer/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_computer/examples/main.rs

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

crates/brk_computer/src/lib.rs

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

crates/brk_computer/src/storage/stores.rs

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

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

@@ -1,430 +0,0 @@
-use core::error;
-use std::{
-    cmp::Ordering,
-    fmt::Debug,
-    ops::Add,
-    path::{Path, PathBuf},
-};
-
-use brk_core::CheckedSub;
-use brk_exit::Exit;
-use brk_vec::{
-    Compressed, DynamicVec, Error, GenericVec, Result, StoredIndex, StoredType, StoredVec, Value,
-    Version,
-};
-use log::info;
-
-const ONE_KIB: usize = 1024;
-const ONE_MIB: usize = ONE_KIB * ONE_KIB;
-const MAX_CACHE_SIZE: usize = 210 * ONE_MIB;
-
-#[derive(Debug)]
-pub struct ComputedVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    computed_version: Option<Version>,
-    inner: StoredVec<I, T>,
-}
-
-impl<I, T> ComputedVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    const SIZE_OF: usize = size_of::<T>();
-
-    pub fn forced_import(
-        path: &Path,
-        version: Version,
-        compressed: Compressed,
-    ) -> brk_vec::Result<Self> {
-        let inner = StoredVec::forced_import(path, version, compressed)?;
-
-        Ok(Self {
-            computed_version: None,
-            inner,
-        })
-    }
-
-    fn safe_truncate_if_needed(&mut self, index: I, exit: &Exit) -> Result<()> {
-        if exit.triggered() {
-            return Ok(());
-        }
-        exit.block();
-        self.inner.truncate_if_needed(index)?;
-        exit.release();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn forced_push_at(&mut self, index: I, value: T, exit: &Exit) -> Result<()> {
-        match self.len().cmp(&index.to_usize()?) {
-            Ordering::Less => {
-                return Err(Error::IndexTooHigh);
-            }
-            ord => {
-                if ord == Ordering::Greater {
-                    self.safe_truncate_if_needed(index, exit)?;
-                }
-                self.inner.push(value);
-            }
-        }
-
-        if self.inner.pushed_len() * Self::SIZE_OF >= MAX_CACHE_SIZE {
-            self.safe_flush(exit)
-        } else {
-            Ok(())
-        }
-    }
-
-    pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {
-        if exit.triggered() {
-            return Ok(());
-        }
-        exit.block();
-        self.inner.flush()?;
-        exit.release();
-        Ok(())
-    }
-
-    fn version(&self) -> Version {
-        self.inner.version()
-    }
-
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-
-    fn file_name(&self) -> String {
-        self.inner.file_name()
-    }
-
-    pub fn vec(&self) -> &StoredVec<I, T> {
-        &self.inner
-    }
-
-    pub fn mut_vec(&mut self) -> &mut StoredVec<I, T> {
-        &mut self.inner
-    }
-
-    pub fn any_vec(&self) -> &dyn brk_vec::AnyStoredVec {
-        &self.inner
-    }
-
-    pub fn mut_any_vec(&mut self) -> &mut dyn brk_vec::AnyStoredVec {
-        &mut self.inner
-    }
-
-    pub fn cached_get(&mut self, index: I) -> Result<Option<Value<T>>> {
-        self.inner.cached_get(index)
-    }
-
-    pub fn collect_inclusive_range(&self, from: I, to: I) -> Result<Vec<T>> {
-        self.inner.collect_inclusive_range(from, to)
-    }
-
-    pub fn path(&self) -> &Path {
-        self.inner.path()
-    }
-
-    #[inline]
-    fn path_computed_version(&self) -> PathBuf {
-        self.inner.path().join("computed_version")
-    }
-
-    fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
-        let path = self.path_computed_version();
-        if version.validate(path.as_ref()).is_err() {
-            self.inner.reset()?;
-        }
-        version.write(path.as_ref())?;
-
-        if self.is_empty() {
-            info!("Computing {}...", self.file_name())
-        }
-
-        Ok(())
-    }
-
-    pub fn compute_transform<A, B, F>(
-        &mut self,
-        max_from: A,
-        other: &mut StoredVec<A, B>,
-        mut t: F,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        A: StoredIndex,
-        B: StoredType,
-        F: FnMut((A, B, &mut Self, &mut dyn DynamicVec<I = A, T = B>)) -> (I, T),
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + other.version(),
-        )?;
-
-        let index = max_from.min(A::from(self.len()));
-        other.iter_from(index, |(a, b, other)| {
-            let (i, v) = t((a, b, self, other));
-            self.forced_push_at(i, v, exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_inverse_more_to_less(
-        &mut self,
-        max_from: T,
-        other: &mut StoredVec<T, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType + StoredIndex,
-        T: StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + other.version(),
-        )?;
-
-        let index = max_from.min(
-            self.inner
-                .cached_get_last()?
-                .map_or_else(T::default, |v| v.into_inner()),
-        );
-        other.iter_from(index, |(v, i, ..)| {
-            if self.cached_get(i).unwrap().is_none_or(|old_v| *old_v > v) {
-                self.forced_push_at(i, v, exit)
-            } else {
-                Ok(())
-            }
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_inverse_less_to_more(
-        &mut self,
-        max_from: T,
-        first_indexes: &mut StoredVec<T, I>,
-        last_indexes: &mut StoredVec<T, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType,
-        T: StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + first_indexes.version() + last_indexes.version(),
-        )?;
-
-        let index = max_from.min(T::from(self.len()));
-        first_indexes.iter_from(index, |(value, first_index, ..)| {
-            let first_index = (first_index).to_usize()?;
-            let last_index = (last_indexes.cached_get(value)?.unwrap()).to_usize()?;
-            (first_index..last_index)
-                .try_for_each(|index| self.forced_push_at(I::from(index), value, exit))
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_last_index_from_first(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut StoredVec<I, T>,
-        final_len: usize,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: Copy + From<usize> + CheckedSub<T> + StoredIndex,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + first_indexes.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        let one = T::from(1);
-        let mut prev_index: Option<I> = None;
-        first_indexes.iter_from(index, |(index, v, ..)| {
-            if let Some(prev_index) = prev_index.take() {
-                let value = v.checked_sub(one).unwrap();
-                self.forced_push_at(prev_index, value, exit)?;
-            }
-            prev_index.replace(index);
-            Ok(())
-        })?;
-        if let Some(prev_index) = prev_index {
-            self.forced_push_at(
-                prev_index,
-                T::from(final_len).checked_sub(one).unwrap(),
-                exit,
-            )?;
-        }
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_count_from_indexes<T2>(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut StoredVec<I, T2>,
-        last_indexes: &mut StoredVec<I, T2>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType
-            + StoredIndex
-            + Copy
-            + Add<usize, Output = T2>
-            + CheckedSub<T2>
-            + TryInto<T>
-            + Default,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-    {
-        let opt: Option<Box<dyn FnMut(T2) -> bool>> = None;
-        self.compute_filtered_count_from_indexes_(max_from, first_indexes, last_indexes, opt, exit)
-    }
-
-    pub fn compute_filtered_count_from_indexes<T2, F>(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut StoredVec<I, T2>,
-        last_indexes: &mut StoredVec<I, T2>,
-        filter: F,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType
-            + StoredIndex
-            + Copy
-            + Add<usize, Output = T2>
-            + CheckedSub<T2>
-            + TryInto<T>
-            + Default,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-        F: FnMut(T2) -> bool,
-    {
-        self.compute_filtered_count_from_indexes_(
-            max_from,
-            first_indexes,
-            last_indexes,
-            Some(Box::new(filter)),
-            exit,
-        )
-    }
-
-    fn compute_filtered_count_from_indexes_<T2>(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut StoredVec<I, T2>,
-        last_indexes: &mut StoredVec<I, T2>,
-        mut filter: Option<Box<dyn FnMut(T2) -> bool + '_>>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<T2>,
-        T2: StoredType
-            + StoredIndex
-            + Copy
-            + Add<usize, Output = T2>
-            + CheckedSub<T2>
-            + TryInto<T>
-            + Default,
-        <T2 as TryInto<T>>::Error: error::Error + 'static,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + first_indexes.version() + last_indexes.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        first_indexes.iter_from(index, |(i, first_index, ..)| {
-            let last_index = last_indexes.cached_get(i)?.unwrap().into_inner();
-            let range = first_index.to_usize().unwrap()..=last_index.to_usize().unwrap();
-            let count = if let Some(filter) = filter.as_mut() {
-                range.into_iter().filter(|i| filter(T2::from(*i))).count()
-            } else {
-                range.count()
-            };
-            self.forced_push_at(i, T::from(T2::from(count)), exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_is_first_ordered<A>(
-        &mut self,
-        max_from: I,
-        self_to_other: &mut StoredVec<I, A>,
-        other_to_self: &mut StoredVec<A, I>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        I: StoredType,
-        T: From<bool>,
-        A: StoredIndex + StoredType,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + self_to_other.version() + other_to_self.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        self_to_other.iter_from(index, |(i, other, ..)| {
-            self.forced_push_at(
-                i,
-                T::from(other_to_self.cached_get(other)?.unwrap().into_inner() == i),
-                exit,
-            )
-        })?;
-
-        self.safe_flush(exit)
-    }
-
-    pub fn compute_sum_from_indexes<T2>(
-        &mut self,
-        max_from: I,
-        first_indexes: &mut StoredVec<I, T2>,
-        last_indexes: &mut StoredVec<I, T2>,
-        source: &mut StoredVec<T2, T>,
-        exit: &Exit,
-    ) -> Result<()>
-    where
-        T: From<usize> + Add<T, Output = T>,
-        T2: StoredIndex + StoredType,
-    {
-        self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.version() + first_indexes.version() + last_indexes.version(),
-        )?;
-
-        let index = max_from.min(I::from(self.len()));
-        first_indexes.iter_from(index, |(i, first_index, ..)| {
-            let last_index = last_indexes.cached_get(i)?.unwrap().into_inner();
-            let range = first_index.to_usize().unwrap()..=last_index.to_usize().unwrap();
-            let mut sum = T::from(0_usize);
-            range.into_iter().for_each(|i| {
-                sum = sum.clone() + source.cached_get_(i).unwrap().unwrap().into_inner();
-            });
-            self.forced_push_at(i, sum, exit)
-        })?;
-
-        self.safe_flush(exit)
-    }
-}
-
-impl<I, T> Clone for ComputedVec<I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    fn clone(&self) -> Self {
-        Self {
-            computed_version: self.computed_version,
-            inner: self.inner.clone(),
-        }
-    }
-}

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

@@ -1,39 +1,55 @@
 use std::{fs, path::Path};
 
-use brk_core::{CheckedSub, Height, StoredU32, StoredU64, StoredUsize, Timestamp, Weight};
+use brk_core::{
+    CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, StoredUsize,
+    Timestamp, Weight,
+};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
 use brk_parser::bitcoin;
-use brk_vec::{Compressed, Version};
+use brk_vec::{AnyCollectableVec, AnyIterableVec, Compressed, Computation, EagerVec, Version};
 
 use super::{
     Indexes,
-    base::ComputedVec,
-    grouped::{ComputedVecsFromHeight, StorableVecGeneatorOptions},
+    grouped::{ComputedVecsFromDateindex, ComputedVecsFromHeight, StorableVecGeneatorOptions},
     indexes,
 };
 
 #[derive(Clone)]
 pub struct Vecs {
-    pub height_to_interval: ComputedVec<Height, Timestamp>,
-    pub indexes_to_block_interval: ComputedVecsFromHeight<Timestamp>,
+    pub height_to_interval: EagerVec<Height, Timestamp>,
+    pub height_to_vbytes: EagerVec<Height, StoredU64>,
+    pub difficultyepoch_to_timestamp: EagerVec<DifficultyEpoch, Timestamp>,
+    pub halvingepoch_to_timestamp: EagerVec<HalvingEpoch, Timestamp>,
+    pub timeindexes_to_timestamp: ComputedVecsFromDateindex<Timestamp>,
     pub indexes_to_block_count: ComputedVecsFromHeight<StoredU32>,
-    pub indexes_to_block_weight: ComputedVecsFromHeight<Weight>,
-    pub height_to_vbytes: ComputedVec<Height, StoredU64>,
-    pub indexes_to_block_vbytes: ComputedVecsFromHeight<StoredU64>,
+    pub indexes_to_block_interval: ComputedVecsFromHeight<Timestamp>,
     pub indexes_to_block_size: ComputedVecsFromHeight<StoredUsize>,
+    pub indexes_to_block_vbytes: ComputedVecsFromHeight<StoredU64>,
+    pub indexes_to_block_weight: ComputedVecsFromHeight<Weight>,
 }
 
 impl Vecs {
-    pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
+    pub fn forced_import(
+        path: &Path,
+        _computation: Computation,
+        compressed: Compressed,
+    ) -> color_eyre::Result<Self> {
         fs::create_dir_all(path)?;
 
         Ok(Self {
-            height_to_interval: ComputedVec::forced_import(
+            height_to_interval: EagerVec::forced_import(
                 &path.join("height_to_interval"),
                 Version::ZERO,
                 compressed,
             )?,
+            timeindexes_to_timestamp: ComputedVecsFromDateindex::forced_import(
+                path,
+                "timestamp",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_first(),
+            )?,
             indexes_to_block_interval: ComputedVecsFromHeight::forced_import(
                 path,
                 "block_interval",
@@ -69,7 +85,7 @@ impl Vecs {
                 compressed,
                 StorableVecGeneatorOptions::default().add_sum().add_total(),
             )?,
-            height_to_vbytes: ComputedVec::forced_import(
+            height_to_vbytes: EagerVec::forced_import(
                 &path.join("height_to_vbytes"),
                 Version::ZERO,
                 compressed,
@@ -82,22 +98,67 @@ impl Vecs {
                 compressed,
                 StorableVecGeneatorOptions::default().add_sum().add_total(),
             )?,
+            difficultyepoch_to_timestamp: EagerVec::forced_import(
+                &path.join("difficultyepoch_to_timestamp"),
+                Version::ZERO,
+                compressed,
+            )?,
+            halvingepoch_to_timestamp: EagerVec::forced_import(
+                &path.join("halvingepoch_to_timestamp"),
+                Version::ZERO,
+                compressed,
+            )?,
         })
     }
 
     pub fn compute(
         &mut self,
-        indexer: &mut Indexer,
-        indexes: &mut indexes::Vecs,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
     ) -> color_eyre::Result<()> {
+        self.timeindexes_to_timestamp.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |vec, _, indexes, starting_indexes, exit| {
+                vec.compute_transform(
+                    starting_indexes.dateindex,
+                    &indexes.dateindex_to_date,
+                    |(di, d, ..)| (di, Timestamp::from(d)),
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_block_count.compute_all(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, indexer, _, starting_indexes, exit| {
+                let indexer_vecs = indexer.vecs();
+
+                v.compute_range(
+                    starting_indexes.height,
+                    &indexer_vecs.height_to_weight,
+                    |h| (h, StoredU32::from(1_u32)),
+                    exit,
+                )
+            },
+        )?;
+
+        let indexer_vecs = indexer.vecs();
+
+        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
         self.height_to_interval.compute_transform(
             starting_indexes.height,
-            indexer.mut_vecs().height_to_timestamp.mut_vec(),
-            |(height, timestamp, _, height_to_timestamp)| {
+            &indexer_vecs.height_to_timestamp,
+            |(height, timestamp, ..)| {
                 let interval = height.decremented().map_or(Timestamp::ZERO, |prev_h| {
-                    let prev_timestamp = *height_to_timestamp.cached_get(prev_h).unwrap().unwrap();
+                    let prev_timestamp = height_to_timestamp_iter.unwrap_get_inner(prev_h);
                     timestamp
                         .checked_sub(prev_timestamp)
                         .unwrap_or(Timestamp::ZERO)
@@ -111,41 +172,26 @@ impl Vecs {
             indexes,
             starting_indexes,
             exit,
-            Some(self.height_to_interval.mut_vec()),
-        )?;
-
-        self.indexes_to_block_count.compute_all(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, indexer, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.height,
-                    indexer.mut_vecs().height_to_weight.mut_vec(),
-                    |(h, ..)| (h, StoredU32::from(1_u32)),
-                    exit,
-                )
-            },
+            Some(&self.height_to_interval),
         )?;
 
         self.indexes_to_block_weight.compute_rest(
             indexes,
             starting_indexes,
             exit,
-            Some(indexer.mut_vecs().height_to_weight.mut_vec()),
+            Some(&indexer_vecs.height_to_weight),
         )?;
 
         self.indexes_to_block_size.compute_rest(
             indexes,
             starting_indexes,
             exit,
-            Some(indexer.mut_vecs().height_to_total_size.mut_vec()),
+            Some(&indexer_vecs.height_to_total_size),
         )?;
 
         self.height_to_vbytes.compute_transform(
             starting_indexes.height,
-            indexer.mut_vecs().height_to_weight.mut_vec(),
+            &indexer_vecs.height_to_weight,
             |(h, w, ..)| {
                 (
                     h,
@@ -159,23 +205,42 @@ impl Vecs {
             indexes,
             starting_indexes,
             exit,
-            Some(self.height_to_vbytes.mut_vec()),
+            Some(&self.height_to_vbytes),
+        )?;
+
+        let mut height_to_timestamp_iter = indexer_vecs.height_to_timestamp.iter();
+
+        self.difficultyepoch_to_timestamp.compute_transform(
+            starting_indexes.difficultyepoch,
+            &indexes.difficultyepoch_to_first_height,
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
+            exit,
+        )?;
+
+        self.halvingepoch_to_timestamp.compute_transform(
+            starting_indexes.halvingepoch,
+            &indexes.halvingepoch_to_first_height,
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
+            exit,
         )?;
 
         Ok(())
     }
 
-    pub fn as_any_vecs(&self) -> Vec<&dyn brk_vec::AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         [
             vec![
-                self.height_to_interval.any_vec(),
-                self.height_to_vbytes.any_vec(),
+                &self.height_to_interval as &dyn AnyCollectableVec,
+                &self.height_to_vbytes,
+                &self.difficultyepoch_to_timestamp,
+                &self.halvingepoch_to_timestamp,
             ],
-            self.indexes_to_block_interval.any_vecs(),
-            self.indexes_to_block_count.any_vecs(),
-            self.indexes_to_block_weight.any_vecs(),
-            self.indexes_to_block_size.any_vecs(),
-            self.indexes_to_block_vbytes.any_vecs(),
+            self.timeindexes_to_timestamp.vecs(),
+            self.indexes_to_block_count.vecs(),
+            self.indexes_to_block_interval.vecs(),
+            self.indexes_to_block_size.vecs(),
+            self.indexes_to_block_vbytes.vecs(),
+            self.indexes_to_block_weight.vecs(),
         ]
         .concat()
     }

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

@@ -1,13 +1,13 @@
 use std::path::Path;
 
+use brk_core::{CheckedSub, StoredUsize};
 use brk_exit::Exit;
 use brk_vec::{
-    Compressed, DynamicVec, GenericVec, Result, StoredIndex, StoredType, StoredVec, Version,
+    AnyCollectableVec, AnyIterableVec, Compressed, EagerVec, Result, StoredIndex, StoredType,
+    Version,
 };
 use color_eyre::eyre::ContextCompat;
 
-use crate::storage::vecs::base::ComputedVec;
-
 use super::ComputedType;
 
 #[derive(Clone, Debug)]
@@ -16,20 +16,22 @@ where
     I: StoredIndex,
     T: ComputedType,
 {
-    pub first: Option<ComputedVec<I, T>>,
-    pub average: Option<ComputedVec<I, T>>,
-    pub sum: Option<ComputedVec<I, T>>,
-    pub max: Option<ComputedVec<I, T>>,
-    pub _90p: Option<ComputedVec<I, T>>,
-    pub _75p: Option<ComputedVec<I, T>>,
-    pub median: Option<ComputedVec<I, T>>,
-    pub _25p: Option<ComputedVec<I, T>>,
-    pub _10p: Option<ComputedVec<I, T>>,
-    pub min: Option<ComputedVec<I, T>>,
-    pub last: Option<ComputedVec<I, T>>,
-    pub total: Option<ComputedVec<I, T>>,
+    first: Option<EagerVec<I, T>>,
+    average: Option<EagerVec<I, T>>,
+    sum: Option<EagerVec<I, T>>,
+    max: Option<EagerVec<I, T>>,
+    _90p: Option<EagerVec<I, T>>,
+    _75p: Option<EagerVec<I, T>>,
+    median: Option<EagerVec<I, T>>,
+    _25p: Option<EagerVec<I, T>>,
+    _10p: Option<EagerVec<I, T>>,
+    min: Option<EagerVec<I, T>>,
+    last: Option<EagerVec<I, T>>,
+    total: Option<EagerVec<I, T>>,
 }
 
+const VERSION: Version = Version::ZERO;
+
 impl<I, T> ComputedVecBuilder<I, T>
 where
     I: StoredIndex,
@@ -38,6 +40,7 @@ where
     pub fn forced_import(
         path: &Path,
         name: &str,
+        version: Version,
         compressed: Compressed,
         options: StorableVecGeneatorOptions,
     ) -> color_eyre::Result<Self> {
@@ -67,57 +70,80 @@ where
             }
         };
 
+        let version = VERSION + version;
+
         let s = Self {
             first: options.first.then(|| {
-                ComputedVec::forced_import(&maybe_prefix("first"), Version::ZERO, compressed)
+                EagerVec::forced_import(&maybe_prefix("first"), version + Version::ZERO, compressed)
                     .unwrap()
             }),
             last: options.last.then(|| {
-                ComputedVec::forced_import(
+                EagerVec::forced_import(
                     &path.join(format!("{key}_to_{name}")),
-                    Version::ZERO,
+                    version + Version::ZERO,
                     compressed,
                 )
                 .unwrap()
             }),
             min: options.min.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("min"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&maybe_suffix("min"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
             max: options.max.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("max"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&maybe_suffix("max"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
             median: options.median.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("median"), Version::ZERO, compressed)
-                    .unwrap()
+                EagerVec::forced_import(
+                    &maybe_suffix("median"),
+                    version + Version::ZERO,
+                    compressed,
+                )
+                .unwrap()
             }),
             average: options.average.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("average"), Version::ZERO, compressed)
-                    .unwrap()
+                EagerVec::forced_import(
+                    &maybe_suffix("average"),
+                    version + Version::ZERO,
+                    compressed,
+                )
+                .unwrap()
             }),
             sum: options.sum.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("sum"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&maybe_suffix("sum"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
             total: options.total.then(|| {
-                ComputedVec::forced_import(&prefix("total"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&prefix("total"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
             _90p: options._90p.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("90p"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&maybe_suffix("90p"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
             _75p: options._75p.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("75p"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&maybe_suffix("75p"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
             _25p: options._25p.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("25p"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&maybe_suffix("25p"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
             _10p: options._10p.then(|| {
-                ComputedVec::forced_import(&maybe_suffix("10p"), Version::ZERO, compressed).unwrap()
+                EagerVec::forced_import(&maybe_suffix("10p"), version + Version::ZERO, compressed)
+                    .unwrap()
             }),
         };
 
         Ok(s)
     }
 
-    pub fn extend(&mut self, max_from: I, source: &mut StoredVec<I, T>, exit: &Exit) -> Result<()> {
+    pub fn extend(
+        &mut self,
+        max_from: I,
+        source: &impl AnyIterableVec<I, T>,
+        exit: &Exit,
+    ) -> Result<()> {
         if self.total.is_none() {
             return Ok(());
         };
@@ -126,21 +152,12 @@ where
 
         let total_vec = self.total.as_mut().unwrap();
 
-        source.iter_from(index, |(i, v, ..)| {
-            let prev = i
-                .to_usize()
-                .unwrap()
-                .checked_sub(1)
-                .map_or(T::from(0_usize), |prev_i| {
-                    total_vec
-                        .cached_get(I::from(prev_i))
-                        .unwrap()
-                        .map_or(T::from(0_usize), |v| v.into_inner())
-                });
-            let value = v.clone() + prev;
-            total_vec.forced_push_at(i, value, exit)?;
-
-            Ok(())
+        let mut total = index.decremented().map_or(T::from(0_usize), |index| {
+            total_vec.iter().unwrap_get_inner(index)
+        });
+        source.iter_at(index).try_for_each(|(i, v)| -> Result<()> {
+            total = total.clone() + v.into_inner();
+            total_vec.forced_push_at(i, total.clone(), exit)
         })?;
 
         self.safe_flush(exit)?;
@@ -151,143 +168,156 @@ where
     pub fn compute<I2>(
         &mut self,
         max_from: I,
-        source: &mut StoredVec<I2, T>,
-        first_indexes: &mut StoredVec<I, I2>,
-        last_indexes: &mut StoredVec<I, I2>,
+        source: &impl AnyIterableVec<I2, T>,
+        first_indexes: &impl AnyIterableVec<I, I2>,
+        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
         exit: &Exit,
     ) -> Result<()>
     where
-        I2: StoredIndex + StoredType,
-        T: Ord + From<f64>,
-        f64: From<T>,
+        I2: StoredIndex + StoredType + CheckedSub<I2>,
     {
         let index = self.starting_index(max_from);
 
-        first_indexes.iter_from(index, |(i, first_index, first_indexes)| {
-            let last_index = last_indexes.cached_get(i)?.unwrap().into_inner();
+        self.validate_computed_version_or_reset_file(
+            source.version() + first_indexes.version() + count_indexes.version(),
+        )?;
 
-            if let Some(first) = self.first.as_mut() {
-                let v = source.cached_get(first_index)?.unwrap().into_inner();
-                first.forced_push_at(index, v, exit)?;
-            }
+        let mut count_indexes_iter = count_indexes.iter();
+        let mut source_iter = source.iter();
 
-            if let Some(last) = self.last.as_mut() {
-                let v = source
-                    .cached_get(last_index)
-                    .inspect_err(|_| {
-                        dbg!(last.path(), last_index);
-                    })?
-                    .unwrap()
-                    .into_inner();
-                last.forced_push_at(index, v, exit)?;
-            }
+        let total_vec = self.total.as_mut();
 
-            let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
-            let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
-            let needs_sorted = self.max.is_some()
-                || self._90p.is_some()
-                || self._75p.is_some()
-                || self.median.is_some()
-                || self._25p.is_some()
-                || self._10p.is_some()
-                || self.min.is_some();
-            let needs_values = needs_sorted || needs_average_sum_or_total;
+        let mut total = total_vec.map(|total_vec| {
+            index.decremented().map_or(T::from(0_usize), |index| {
+                total_vec.iter().unwrap_get_inner(index)
+            })
+        });
 
-            if needs_values {
-                let mut values = source.collect_inclusive_range(first_index, last_index)?;
+        first_indexes
+            .iter_at(index)
+            .try_for_each(|(i, first_index)| -> Result<()> {
+                let first_index = first_index.into_inner();
 
-                if needs_sorted {
-                    values.sort_unstable();
+                let count_index = count_indexes_iter.unwrap_get_inner(i);
 
-                    if let Some(max) = self.max.as_mut() {
-                        max.forced_push_at(
-                            i,
-                            values
-                                .last()
-                                .context("expect some")
-                                .inspect_err(|_| {
-                                    dbg!(
-                                        &values,
-                                        max.path(),
-                                        first_indexes.path(),
-                                        first_index,
-                                        last_indexes.path(),
-                                        last_index,
-                                        source.len(),
-                                        source.path()
-                                    );
-                                })
-                                .unwrap()
-                                .clone(),
-                            exit,
-                        )?;
-                    }
-
-                    if let Some(_90p) = self._90p.as_mut() {
-                        _90p.forced_push_at(i, Self::get_percentile(&values, 0.90), exit)?;
-                    }
-
-                    if let Some(_75p) = self._75p.as_mut() {
-                        _75p.forced_push_at(i, Self::get_percentile(&values, 0.75), exit)?;
-                    }
-
-                    if let Some(median) = self.median.as_mut() {
-                        median.forced_push_at(i, Self::get_percentile(&values, 0.50), exit)?;
-                    }
-
-                    if let Some(_25p) = self._25p.as_mut() {
-                        _25p.forced_push_at(i, Self::get_percentile(&values, 0.25), exit)?;
-                    }
-
-                    if let Some(_10p) = self._10p.as_mut() {
-                        _10p.forced_push_at(i, Self::get_percentile(&values, 0.10), exit)?;
-                    }
-
-                    if let Some(min) = self.min.as_mut() {
-                        min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
-                    }
+                if let Some(first) = self.first.as_mut() {
+                    let f = source_iter
+                        .get_inner(first_index)
+                        .unwrap_or_else(|| T::from(0_usize));
+                    first.forced_push_at(index, f, exit)?;
                 }
 
-                if needs_average_sum_or_total {
-                    let len = values.len();
+                if let Some(last) = self.last.as_mut() {
+                    let count_index = *count_index;
+                    if count_index == 0 {
+                        panic!("should compute last if count can be 0")
+                    }
+                    let last_index = first_index + (count_index - 1);
+                    let v = source_iter.unwrap_get_inner(last_index);
+                    // .context("to work")
+                    // .inspect_err(|_| {
+                    //     dbg!(first_index, count_index, last_index);
+                    // })
+                    // .unwrap()
+                    // .into_inner();
+                    last.forced_push_at(index, v, exit)?;
+                }
 
-                    if let Some(average) = self.average.as_mut() {
-                        let len = len as f64;
-                        let total = values
-                            .iter()
-                            .map(|v| f64::from(v.clone()))
-                            .fold(0.0, |a, b| a + b);
-                        let avg = T::from(total / len);
-                        average.forced_push_at(i, avg, exit)?;
+                let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
+                let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
+                let needs_sorted = self.max.is_some()
+                    || self._90p.is_some()
+                    || self._75p.is_some()
+                    || self.median.is_some()
+                    || self._25p.is_some()
+                    || self._10p.is_some()
+                    || self.min.is_some();
+                let needs_values = needs_sorted || needs_average_sum_or_total;
+
+                if needs_values {
+                    source_iter.set(first_index);
+                    let mut values = (&mut source_iter)
+                        .take(*count_index)
+                        .map(|(_, v)| v.into_inner())
+                        .collect::<Vec<_>>();
+
+                    if needs_sorted {
+                        values.sort_unstable();
+
+                        if let Some(max) = self.max.as_mut() {
+                            max.forced_push_at(
+                                i,
+                                values
+                                    .last()
+                                    .context("expect some")
+                                    .inspect_err(|_| {
+                                        dbg!(
+                                            &values,
+                                            max.path(),
+                                            first_indexes.name(),
+                                            first_index,
+                                            count_indexes.name(),
+                                            count_index,
+                                            source.len(),
+                                            source.name()
+                                        );
+                                    })
+                                    .unwrap()
+                                    .clone(),
+                                exit,
+                            )?;
+                        }
+
+                        if let Some(_90p) = self._90p.as_mut() {
+                            _90p.forced_push_at(i, Self::get_percentile(&values, 0.90), exit)?;
+                        }
+
+                        if let Some(_75p) = self._75p.as_mut() {
+                            _75p.forced_push_at(i, Self::get_percentile(&values, 0.75), exit)?;
+                        }
+
+                        if let Some(median) = self.median.as_mut() {
+                            median.forced_push_at(i, Self::get_percentile(&values, 0.50), exit)?;
+                        }
+
+                        if let Some(_25p) = self._25p.as_mut() {
+                            _25p.forced_push_at(i, Self::get_percentile(&values, 0.25), exit)?;
+                        }
+
+                        if let Some(_10p) = self._10p.as_mut() {
+                            _10p.forced_push_at(i, Self::get_percentile(&values, 0.10), exit)?;
+                        }
+
+                        if let Some(min) = self.min.as_mut() {
+                            min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
+                        }
                     }
 
-                    if needs_sum_or_total {
+                    if needs_average_sum_or_total {
+                        let len = values.len();
                         let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
 
-                        if let Some(sum_vec) = self.sum.as_mut() {
-                            sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                        if let Some(average) = self.average.as_mut() {
+                            let avg = sum.clone() / len;
+                            average.forced_push_at(i, avg, exit)?;
                         }
 
-                        if let Some(total_vec) = self.total.as_mut() {
-                            let prev = i.to_usize().unwrap().checked_sub(1).map_or(
-                                T::from(0_usize),
-                                |prev_i| {
-                                    total_vec
-                                        .cached_get(I::from(prev_i))
-                                        .unwrap()
-                                        .unwrap()
-                                        .to_owned()
-                                        .into_inner()
-                                },
-                            );
-                            total_vec.forced_push_at(i, prev + sum, exit)?;
+                        if needs_sum_or_total {
+                            if let Some(sum_vec) = self.sum.as_mut() {
+                                sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                            }
+
+                            if let Some(total_vec) = self.total.as_mut() {
+                                let t = total.as_ref().unwrap().clone() + sum;
+                                total.replace(t.clone());
+                                total_vec.forced_push_at(i, t, exit)?;
+                            }
                         }
                     }
                 }
-            }
 
-            Ok(())
-        })?;
+                Ok(())
+            })?;
 
         self.safe_flush(exit)?;
 
@@ -298,15 +328,13 @@ where
     pub fn from_aligned<I2>(
         &mut self,
         max_from: I,
-        source: &mut ComputedVecBuilder<I2, T>,
-        first_indexes: &mut StoredVec<I, I2>,
-        last_indexes: &mut StoredVec<I, I2>,
+        source: &ComputedVecBuilder<I2, T>,
+        first_indexes: &impl AnyIterableVec<I, I2>,
+        count_indexes: &impl AnyIterableVec<I, StoredUsize>,
         exit: &Exit,
     ) -> Result<()>
     where
-        I2: StoredIndex + StoredType,
-        T: Ord + From<f64>,
-        f64: From<T>,
+        I2: StoredIndex + StoredType + CheckedSub<I2>,
     {
         if self._90p.is_some()
             || self._75p.is_some()
@@ -317,112 +345,127 @@ where
             panic!("unsupported");
         }
 
+        self.validate_computed_version_or_reset_file(
+            VERSION + first_indexes.version() + count_indexes.version(),
+        )?;
+
         let index = self.starting_index(max_from);
 
-        first_indexes.iter_from(index, |(i, first_index, ..)| {
-            let last_index = *last_indexes.cached_get(i).unwrap().unwrap();
+        let mut count_indexes_iter = count_indexes.iter();
 
-            if let Some(first) = self.first.as_mut() {
-                let v = source
-                    .first
-                    .as_mut()
-                    .unwrap()
-                    .cached_get(first_index)
-                    .unwrap()
-                    .unwrap()
-                    .into_inner();
-                first.forced_push_at(index, v, exit)?;
-            }
+        let mut source_first_iter = source.first.as_ref().map(|f| f.iter());
+        let mut source_last_iter = source.last.as_ref().map(|f| f.iter());
+        let mut source_max_iter = source.max.as_ref().map(|f| f.iter());
+        let mut source_min_iter = source.min.as_ref().map(|f| f.iter());
+        let mut source_average_iter = source.average.as_ref().map(|f| f.iter());
+        let mut source_sum_iter = source.sum.as_ref().map(|f| f.iter());
 
-            if let Some(last) = self.last.as_mut() {
-                let v = source
-                    .last
-                    .as_mut()
-                    .unwrap()
-                    .cached_get(last_index)
-                    .unwrap()
-                    .unwrap()
-                    .into_inner();
-                last.forced_push_at(index, v, exit)?;
-            }
+        let mut total = self.total.as_mut().map(|total_vec| {
+            index.decremented().map_or(T::from(0_usize), |index| {
+                total_vec.iter().unwrap_get_inner(index)
+            })
+        });
 
-            let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
-            let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
-            let needs_sorted = self.max.is_some() || self.min.is_some();
-            let needs_values = needs_sorted || needs_average_sum_or_total;
+        first_indexes
+            .iter_at(index)
+            .try_for_each(|(i, first_index, ..)| -> Result<()> {
+                let first_index = first_index.into_inner();
 
-            if needs_values {
-                if needs_sorted {
-                    if let Some(max) = self.max.as_mut() {
-                        let mut values = source
-                            .max
-                            .as_ref()
-                            .unwrap()
-                            .collect_inclusive_range(first_index, last_index)?;
-                        values.sort_unstable();
-                        max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
-                    }
+                let count_index = count_indexes_iter.unwrap_get_inner(i);
 
-                    if let Some(min) = self.min.as_mut() {
-                        let mut values = source
-                            .min
-                            .as_ref()
-                            .unwrap()
-                            .collect_inclusive_range(first_index, last_index)?;
-                        values.sort_unstable();
-                        min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
-                    }
+                if let Some(first) = self.first.as_mut() {
+                    let v = source_first_iter
+                        .as_mut()
+                        .unwrap()
+                        .unwrap_get_inner(first_index);
+                    first.forced_push_at(index, v, exit)?;
                 }
 
-                if needs_average_sum_or_total {
-                    if let Some(average) = self.average.as_mut() {
-                        let values = source
-                            .average
-                            .as_ref()
-                            .unwrap()
-                            .collect_inclusive_range(first_index, last_index)?;
-                        let len = values.len() as f64;
-                        let total = values
-                            .into_iter()
-                            .map(|v| f64::from(v))
-                            .fold(0.0, |a, b| a + b);
-                        // TODO: Multiply by count then divide by total
-                        // Right now it's not 100% accurate as there could be more or less elements in the lower timeframe (28 days vs 31 days in a month for example)
-                        let avg = T::from(total / len);
-                        average.forced_push_at(i, avg, exit)?;
+                if let Some(last) = self.last.as_mut() {
+                    let count_index = *count_index;
+                    if count_index == 0 {
+                        panic!("should compute last if count can be 0")
                     }
+                    let last_index = first_index + (count_index - 1);
+                    let v = source_last_iter
+                        .as_mut()
+                        .unwrap()
+                        .unwrap_get_inner(last_index);
+                    last.forced_push_at(index, v, exit)?;
+                }
 
-                    if needs_sum_or_total {
-                        let values = source
-                            .sum
-                            .as_ref()
-                            .unwrap()
-                            .collect_inclusive_range(first_index, last_index)?;
-                        let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
+                let needs_sum_or_total = self.sum.is_some() || self.total.is_some();
+                let needs_average_sum_or_total = needs_sum_or_total || self.average.is_some();
+                let needs_sorted = self.max.is_some() || self.min.is_some();
+                let needs_values = needs_sorted || needs_average_sum_or_total;
 
-                        if let Some(sum_vec) = self.sum.as_mut() {
-                            sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                if needs_values {
+                    if needs_sorted {
+                        if let Some(max) = self.max.as_mut() {
+                            let source_max_iter = source_max_iter.as_mut().unwrap();
+                            source_max_iter.set(first_index);
+                            let mut values = source_max_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+                            values.sort_unstable();
+                            max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
                         }
 
-                        if let Some(total_vec) = self.total.as_mut() {
-                            let prev = i.to_usize().unwrap().checked_sub(1).map_or(
-                                T::from(0_usize),
-                                |prev_i| {
-                                    total_vec
-                                        .cached_get(I::from(prev_i))
-                                        .unwrap()
-                                        .unwrap()
-                                        .into_inner()
-                                },
-                            );
-                            total_vec.forced_push_at(i, prev + sum, exit)?;
+                        if let Some(min) = self.min.as_mut() {
+                            let source_min_iter = source_min_iter.as_mut().unwrap();
+                            source_min_iter.set(first_index);
+                            let mut values = source_min_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+                            values.sort_unstable();
+                            min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
+                        }
+                    }
+
+                    if needs_average_sum_or_total {
+                        if let Some(average) = self.average.as_mut() {
+                            let source_average_iter = source_average_iter.as_mut().unwrap();
+                            source_average_iter.set(first_index);
+                            let values = source_average_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+
+                            let len = values.len();
+                            let total = values.into_iter().fold(T::from(0), |a, b| a + b);
+                            // TODO: Multiply by count then divide by total
+                            // Right now it's not 100% accurate as there could be more or less elements in the lower timeframe (28 days vs 31 days in a month for example)
+                            let avg = total / len;
+                            average.forced_push_at(i, avg, exit)?;
+                        }
+
+                        if needs_sum_or_total {
+                            let source_sum_iter = source_sum_iter.as_mut().unwrap();
+                            source_sum_iter.set(first_index);
+                            let values = source_sum_iter
+                                .take(*count_index)
+                                .map(|(_, v)| v.into_inner())
+                                .collect::<Vec<_>>();
+
+                            let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
+
+                            if let Some(sum_vec) = self.sum.as_mut() {
+                                sum_vec.forced_push_at(i, sum.clone(), exit)?;
+                            }
+
+                            if let Some(total_vec) = self.total.as_mut() {
+                                let t = total.as_ref().unwrap().clone() + sum;
+                                total.replace(t.clone());
+                                total_vec.forced_push_at(i, t, exit)?;
+                            }
                         }
                     }
                 }
-            }
 
-            Ok(())
-        })?;
+                Ok(())
+            })?;
 
         self.safe_flush(exit)?;
 
@@ -453,48 +496,92 @@ where
 
     fn starting_index(&self, max_from: I) -> I {
         max_from.min(I::from(
-            self.any_vecs().into_iter().map(|v| v.len()).min().unwrap(),
+            self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
         ))
     }
 
-    pub fn any_vecs(&self) -> Vec<&dyn brk_vec::AnyStoredVec> {
-        let mut v: Vec<&dyn brk_vec::AnyStoredVec> = vec![];
+    pub fn unwrap_first(&mut self) -> &mut EagerVec<I, T> {
+        self.first.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_average(&mut self) -> &mut EagerVec<I, T> {
+        self.average.as_mut().unwrap()
+    }
+    pub fn unwrap_sum(&mut self) -> &mut EagerVec<I, T> {
+        self.sum.as_mut().unwrap()
+    }
+    pub fn unwrap_max(&mut self) -> &mut EagerVec<I, T> {
+        self.max.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_90p(&mut self) -> &mut EagerVec<I, T> {
+        self._90p.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_75p(&mut self) -> &mut EagerVec<I, T> {
+        self._75p.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_median(&mut self) -> &mut EagerVec<I, T> {
+        self.median.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_25p(&mut self) -> &mut EagerVec<I, T> {
+        self._25p.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_10p(&mut self) -> &mut EagerVec<I, T> {
+        self._10p.as_mut().unwrap()
+    }
+    pub fn unwrap_min(&mut self) -> &mut EagerVec<I, T> {
+        self.min.as_mut().unwrap()
+    }
+    pub fn unwrap_last(&mut self) -> &mut EagerVec<I, T> {
+        self.last.as_mut().unwrap()
+    }
+    #[allow(unused)]
+    pub fn unwrap_total(&mut self) -> &mut EagerVec<I, T> {
+        self.total.as_mut().unwrap()
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        let mut v: Vec<&dyn AnyCollectableVec> = vec![];
 
         if let Some(first) = self.first.as_ref() {
-            v.push(first.any_vec());
+            v.push(first);
         }
         if let Some(last) = self.last.as_ref() {
-            v.push(last.any_vec());
+            v.push(last);
         }
         if let Some(min) = self.min.as_ref() {
-            v.push(min.any_vec());
+            v.push(min);
         }
         if let Some(max) = self.max.as_ref() {
-            v.push(max.any_vec());
+            v.push(max);
         }
         if let Some(median) = self.median.as_ref() {
-            v.push(median.any_vec());
+            v.push(median);
         }
         if let Some(average) = self.average.as_ref() {
-            v.push(average.any_vec());
+            v.push(average);
         }
         if let Some(sum) = self.sum.as_ref() {
-            v.push(sum.any_vec());
+            v.push(sum);
         }
         if let Some(total) = self.total.as_ref() {
-            v.push(total.any_vec());
+            v.push(total);
         }
         if let Some(_90p) = self._90p.as_ref() {
-            v.push(_90p.any_vec());
+            v.push(_90p);
         }
         if let Some(_75p) = self._75p.as_ref() {
-            v.push(_75p.any_vec());
+            v.push(_75p);
         }
         if let Some(_25p) = self._25p.as_ref() {
-            v.push(_25p.any_vec());
+            v.push(_25p);
         }
         if let Some(_10p) = self._10p.as_ref() {
-            v.push(_10p.any_vec());
+            v.push(_10p);
         }
 
         v
@@ -540,6 +627,47 @@ where
 
         Ok(())
     }
+
+    fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
+        if let Some(first) = self.first.as_mut() {
+            first.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(last) = self.last.as_mut() {
+            last.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(min) = self.min.as_mut() {
+            min.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(max) = self.max.as_mut() {
+            max.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(median) = self.median.as_mut() {
+            median.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(average) = self.average.as_mut() {
+            average.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(sum) = self.sum.as_mut() {
+            sum.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(total) = self.total.as_mut() {
+            total.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_90p) = self._90p.as_mut() {
+            _90p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_75p) = self._75p.as_mut() {
+            _75p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_25p) = self._25p.as_mut() {
+            _25p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+        if let Some(_10p) = self._10p.as_mut() {
+            _10p.validate_computed_version_or_reset_file(Version::ZERO + version)?;
+        }
+
+        Ok(())
+    }
 }
 
 #[derive(Default, Clone, Copy)]
@@ -579,6 +707,7 @@ impl StorableVecGeneatorOptions {
         self
     }
 
+    #[allow(unused)]
     pub fn add_median(mut self) -> Self {
         self.median = true;
         self
@@ -594,21 +723,25 @@ impl StorableVecGeneatorOptions {
         self
     }
 
+    #[allow(unused)]
     pub fn add_90p(mut self) -> Self {
         self._90p = true;
         self
     }
 
+    #[allow(unused)]
     pub fn add_75p(mut self) -> Self {
         self._75p = true;
         self
     }
 
+    #[allow(unused)]
     pub fn add_25p(mut self) -> Self {
         self._25p = true;
         self
     }
 
+    #[allow(unused)]
     pub fn add_10p(mut self) -> Self {
         self._10p = true;
         self
@@ -619,51 +752,61 @@ impl StorableVecGeneatorOptions {
         self
     }
 
+    #[allow(unused)]
     pub fn rm_min(mut self) -> Self {
         self.min = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_max(mut self) -> Self {
         self.max = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_median(mut self) -> Self {
         self.median = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_average(mut self) -> Self {
         self.average = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_sum(mut self) -> Self {
         self.sum = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_90p(mut self) -> Self {
         self._90p = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_75p(mut self) -> Self {
         self._75p = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_25p(mut self) -> Self {
         self._25p = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_10p(mut self) -> Self {
         self._10p = false;
         self
     }
 
+    #[allow(unused)]
     pub fn rm_total(mut self) -> Self {
         self.total = false;
         self

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

@@ -1,11 +1,11 @@
 use std::path::Path;
 
-use brk_core::{Dateindex, Decadeindex, Monthindex, Quarterindex, Weekindex, Yearindex};
+use brk_core::{DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, Version};
+use brk_vec::{AnyCollectableVec, Compressed, EagerVec, Result, Version};
 
-use crate::storage::vecs::{Indexes, base::ComputedVec, indexes};
+use crate::storage::{Indexes, indexes};
 
 use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
 
@@ -14,19 +14,20 @@ pub struct ComputedVecsFromDateindex<T>
 where
     T: ComputedType + PartialOrd,
 {
-    pub dateindex: ComputedVec<Dateindex, T>,
-    pub dateindex_extra: ComputedVecBuilder<Dateindex, T>,
-    pub weekindex: ComputedVecBuilder<Weekindex, T>,
-    pub monthindex: ComputedVecBuilder<Monthindex, T>,
-    pub quarterindex: ComputedVecBuilder<Quarterindex, T>,
-    pub yearindex: ComputedVecBuilder<Yearindex, T>,
-    pub decadeindex: ComputedVecBuilder<Decadeindex, T>,
+    pub dateindex: EagerVec<DateIndex, T>,
+    pub dateindex_extra: ComputedVecBuilder<DateIndex, T>,
+    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
+    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
+    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    pub yearindex: ComputedVecBuilder<YearIndex, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
 }
 
+const VERSION: Version = Version::ZERO;
+
 impl<T> ComputedVecsFromDateindex<T>
 where
-    T: ComputedType + Ord + From<f64>,
-    f64: From<T>,
+    T: ComputedType,
 {
     pub fn forced_import(
         path: &Path,
@@ -35,39 +36,52 @@ where
         compressed: Compressed,
         options: StorableVecGeneatorOptions,
     ) -> color_eyre::Result<Self> {
-        let dateindex_extra =
-            ComputedVecBuilder::forced_import(path, name, compressed, options.copy_self_extra())?;
+        let version = VERSION + version;
+
+        let dateindex_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version,
+            compressed,
+            options.copy_self_extra(),
+        )?;
 
         let options = options.remove_percentiles();
 
         Ok(Self {
-            dateindex: ComputedVec::forced_import(
+            dateindex: EagerVec::forced_import(
                 &path.join(format!("dateindex_to_{name}")),
                 version,
                 compressed,
             )?,
             dateindex_extra,
-            weekindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            monthindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            quarterindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            yearindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            decadeindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            weekindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
         })
     }
 
     pub fn compute<F>(
         &mut self,
-        indexer: &mut Indexer,
-        indexes: &mut indexes::Vecs,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
         mut compute: F,
     ) -> color_eyre::Result<()>
     where
         F: FnMut(
-            &mut ComputedVec<Dateindex, T>,
-            &mut Indexer,
-            &mut indexes::Vecs,
+            &mut EagerVec<DateIndex, T>,
+            &Indexer,
+            &indexes::Vecs,
             &Indexes,
             &Exit,
         ) -> Result<()>,
@@ -81,60 +95,60 @@ where
         )?;
 
         self.dateindex_extra
-            .extend(starting_indexes.dateindex, self.dateindex.mut_vec(), exit)?;
+            .extend(starting_indexes.dateindex, &self.dateindex, exit)?;
 
         self.weekindex.compute(
             starting_indexes.weekindex,
-            self.dateindex.mut_vec(),
-            indexes.weekindex_to_first_dateindex.mut_vec(),
-            indexes.weekindex_to_last_dateindex.mut_vec(),
+            &self.dateindex,
+            &indexes.weekindex_to_first_dateindex,
+            &indexes.weekindex_to_dateindex_count,
             exit,
         )?;
 
         self.monthindex.compute(
             starting_indexes.monthindex,
-            self.dateindex.mut_vec(),
-            indexes.monthindex_to_first_dateindex.mut_vec(),
-            indexes.monthindex_to_last_dateindex.mut_vec(),
+            &self.dateindex,
+            &indexes.monthindex_to_first_dateindex,
+            &indexes.monthindex_to_dateindex_count,
             exit,
         )?;
 
         self.quarterindex.from_aligned(
             starting_indexes.quarterindex,
-            &mut self.monthindex,
-            indexes.quarterindex_to_first_monthindex.mut_vec(),
-            indexes.quarterindex_to_last_monthindex.mut_vec(),
+            &self.monthindex,
+            &indexes.quarterindex_to_first_monthindex,
+            &indexes.quarterindex_to_monthindex_count,
             exit,
         )?;
 
         self.yearindex.from_aligned(
             starting_indexes.yearindex,
-            &mut self.monthindex,
-            indexes.yearindex_to_first_monthindex.mut_vec(),
-            indexes.yearindex_to_last_monthindex.mut_vec(),
+            &self.monthindex,
+            &indexes.yearindex_to_first_monthindex,
+            &indexes.yearindex_to_monthindex_count,
             exit,
         )?;
 
         self.decadeindex.from_aligned(
             starting_indexes.decadeindex,
-            &mut self.yearindex,
-            indexes.decadeindex_to_first_yearindex.mut_vec(),
-            indexes.decadeindex_to_last_yearindex.mut_vec(),
+            &self.yearindex,
+            &indexes.decadeindex_to_first_yearindex,
+            &indexes.decadeindex_to_yearindex_count,
             exit,
         )?;
 
         Ok(())
     }
 
-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         [
-            vec![self.dateindex.any_vec()],
-            self.dateindex_extra.any_vecs(),
-            self.weekindex.any_vecs(),
-            self.monthindex.any_vecs(),
-            self.quarterindex.any_vecs(),
-            self.yearindex.any_vecs(),
-            self.decadeindex.any_vecs(),
+            vec![&self.dateindex as &dyn AnyCollectableVec],
+            self.dateindex_extra.vecs(),
+            self.weekindex.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.yearindex.vecs(),
+            self.decadeindex.vecs(),
         ]
         .concat()
     }

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

@@ -1,13 +1,13 @@
 use std::path::Path;
 
 use brk_core::{
-    Dateindex, Decadeindex, Difficultyepoch, Height, Monthindex, Quarterindex, Weekindex, Yearindex,
+    DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, WeekIndex, YearIndex,
 };
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, StoredVec, Version};
+use brk_vec::{AnyCollectableVec, AnyIterableVec, Compressed, EagerVec, Result, Version};
 
-use crate::storage::vecs::{Indexes, base::ComputedVec, indexes};
+use crate::storage::{Indexes, indexes};
 
 use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
 
@@ -16,18 +16,20 @@ pub struct ComputedVecsFromHeight<T>
 where
     T: ComputedType + PartialOrd,
 {
-    pub height: Option<ComputedVec<Height, T>>,
+    pub height: Option<EagerVec<Height, T>>,
     pub height_extra: ComputedVecBuilder<Height, T>,
-    pub dateindex: ComputedVecBuilder<Dateindex, T>,
-    pub weekindex: ComputedVecBuilder<Weekindex, T>,
-    pub difficultyepoch: ComputedVecBuilder<Difficultyepoch, T>,
-    pub monthindex: ComputedVecBuilder<Monthindex, T>,
-    pub quarterindex: ComputedVecBuilder<Quarterindex, T>,
-    pub yearindex: ComputedVecBuilder<Yearindex, T>,
+    pub dateindex: ComputedVecBuilder<DateIndex, T>,
+    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
+    pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
+    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
+    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    pub yearindex: ComputedVecBuilder<YearIndex, T>,
     // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
-    pub decadeindex: ComputedVecBuilder<Decadeindex, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
 }
 
+const VERSION: Version = Version::ZERO;
+
 impl<T> ComputedVecsFromHeight<T>
 where
     T: ComputedType + Ord + From<f64>,
@@ -41,15 +43,23 @@ where
         compressed: Compressed,
         options: StorableVecGeneatorOptions,
     ) -> color_eyre::Result<Self> {
+        let version = VERSION + version;
+
         let height = compute_source.then(|| {
-            ComputedVec::forced_import(&path.join(format!("height_to_{name}")), version, compressed)
+            EagerVec::forced_import(&path.join(format!("height_to_{name}")), version, compressed)
                 .unwrap()
         });
 
-        let height_extra =
-            ComputedVecBuilder::forced_import(path, name, compressed, options.copy_self_extra())?;
+        let height_extra = ComputedVecBuilder::forced_import(
+            path,
+            name,
+            version,
+            compressed,
+            options.copy_self_extra(),
+        )?;
 
-        let dateindex = ComputedVecBuilder::forced_import(path, name, compressed, options)?;
+        let dateindex =
+            ComputedVecBuilder::forced_import(path, name, version, compressed, options)?;
 
         let options = options.remove_percentiles();
 
@@ -57,32 +67,34 @@ where
             height,
             height_extra,
             dateindex,
-            weekindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            difficultyepoch: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            monthindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            quarterindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            yearindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            // halvingepoch: StorableVecGeneator::forced_import(path, name, compressed, options)?,
-            decadeindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            weekindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            difficultyepoch: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
         })
     }
 
     pub fn compute_all<F>(
         &mut self,
-        indexer: &mut Indexer,
-        indexes: &mut indexes::Vecs,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
         mut compute: F,
     ) -> color_eyre::Result<()>
     where
-        F: FnMut(
-            &mut ComputedVec<Height, T>,
-            &mut Indexer,
-            &mut indexes::Vecs,
-            &Indexes,
-            &Exit,
-        ) -> Result<()>,
+        F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>,
     {
         compute(
             self.height.as_mut().unwrap(),
@@ -92,94 +104,118 @@ where
             exit,
         )?;
 
-        self.compute_rest(indexes, starting_indexes, exit, None)?;
+        let height: Option<&EagerVec<Height, T>> = None;
+        self.compute_rest(indexes, starting_indexes, exit, height)?;
 
         Ok(())
     }
 
     pub fn compute_rest(
         &mut self,
-        indexes: &mut indexes::Vecs,
+        indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
-        height: Option<&mut StoredVec<Height, T>>,
+        height: Option<&impl AnyIterableVec<Height, T>>,
     ) -> color_eyre::Result<()> {
-        let height = height.unwrap_or_else(|| self.height.as_mut().unwrap().mut_vec());
+        if let Some(height) = height {
+            self.height_extra
+                .extend(starting_indexes.height, height, exit)?;
 
-        self.height_extra
-            .extend(starting_indexes.height, height, exit)?;
+            self.dateindex.compute(
+                starting_indexes.dateindex,
+                height,
+                &indexes.dateindex_to_first_height,
+                &indexes.dateindex_to_height_count,
+                exit,
+            )?;
 
-        self.dateindex.compute(
-            starting_indexes.dateindex,
-            height,
-            indexes.dateindex_to_first_height.mut_vec(),
-            indexes.dateindex_to_last_height.mut_vec(),
-            exit,
-        )?;
+            self.difficultyepoch.compute(
+                starting_indexes.difficultyepoch,
+                height,
+                &indexes.difficultyepoch_to_first_height,
+                &indexes.difficultyepoch_to_height_count,
+                exit,
+            )?;
+        } else {
+            let height = self.height.as_ref().unwrap();
+
+            self.height_extra
+                .extend(starting_indexes.height, height, exit)?;
+
+            self.dateindex.compute(
+                starting_indexes.dateindex,
+                height,
+                &indexes.dateindex_to_first_height,
+                &indexes.dateindex_to_height_count,
+                exit,
+            )?;
+
+            self.difficultyepoch.compute(
+                starting_indexes.difficultyepoch,
+                height,
+                &indexes.difficultyepoch_to_first_height,
+                &indexes.difficultyepoch_to_height_count,
+                exit,
+            )?;
+        }
 
         self.weekindex.from_aligned(
             starting_indexes.weekindex,
-            &mut self.dateindex,
-            indexes.weekindex_to_first_dateindex.mut_vec(),
-            indexes.weekindex_to_last_dateindex.mut_vec(),
+            &self.dateindex,
+            &indexes.weekindex_to_first_dateindex,
+            &indexes.weekindex_to_dateindex_count,
             exit,
         )?;
 
         self.monthindex.from_aligned(
             starting_indexes.monthindex,
-            &mut self.dateindex,
-            indexes.monthindex_to_first_dateindex.mut_vec(),
-            indexes.monthindex_to_last_dateindex.mut_vec(),
+            &self.dateindex,
+            &indexes.monthindex_to_first_dateindex,
+            &indexes.monthindex_to_dateindex_count,
             exit,
         )?;
 
         self.quarterindex.from_aligned(
             starting_indexes.quarterindex,
-            &mut self.monthindex,
-            indexes.quarterindex_to_first_monthindex.mut_vec(),
-            indexes.quarterindex_to_last_monthindex.mut_vec(),
+            &self.monthindex,
+            &indexes.quarterindex_to_first_monthindex,
+            &indexes.quarterindex_to_monthindex_count,
             exit,
         )?;
 
         self.yearindex.from_aligned(
             starting_indexes.yearindex,
-            &mut self.monthindex,
-            indexes.yearindex_to_first_monthindex.mut_vec(),
-            indexes.yearindex_to_last_monthindex.mut_vec(),
+            &self.monthindex,
+            &indexes.yearindex_to_first_monthindex,
+            &indexes.yearindex_to_monthindex_count,
             exit,
         )?;
 
         self.decadeindex.from_aligned(
             starting_indexes.decadeindex,
-            &mut self.yearindex,
-            indexes.decadeindex_to_first_yearindex.mut_vec(),
-            indexes.decadeindex_to_last_yearindex.mut_vec(),
-            exit,
-        )?;
-
-        self.difficultyepoch.compute(
-            starting_indexes.difficultyepoch,
-            height,
-            indexes.difficultyepoch_to_first_height.mut_vec(),
-            indexes.difficultyepoch_to_last_height.mut_vec(),
+            &self.yearindex,
+            &indexes.decadeindex_to_first_yearindex,
+            &indexes.decadeindex_to_yearindex_count,
             exit,
         )?;
 
         Ok(())
     }
 
-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         [
-            self.height.as_ref().map_or(vec![], |v| vec![v.any_vec()]),
-            self.height_extra.any_vecs(),
-            self.dateindex.any_vecs(),
-            self.weekindex.any_vecs(),
-            self.difficultyepoch.any_vecs(),
-            self.monthindex.any_vecs(),
-            self.quarterindex.any_vecs(),
-            self.yearindex.any_vecs(),
-            // self.halvingepoch.as_any_vecs(),
-            self.decadeindex.any_vecs(),
+            self.height
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
+            self.height_extra.vecs(),
+            self.dateindex.vecs(),
+            self.weekindex.vecs(),
+            self.difficultyepoch.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.yearindex.vecs(),
+            // self.halvingepoch.vecs(),
+            self.decadeindex.vecs(),
         ]
         .concat()
     }

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

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

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

@@ -1,14 +1,16 @@
 use std::path::Path;
 
 use brk_core::{
-    Dateindex, Decadeindex, Difficultyepoch, Height, Monthindex, Quarterindex, Txindex, Weekindex,
-    Yearindex,
+    DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, TxIndex, WeekIndex,
+    YearIndex,
 };
 use brk_exit::Exit;
 use brk_indexer::Indexer;
-use brk_vec::{AnyStoredVec, Compressed, Result, StoredVec, Version};
+use brk_vec::{
+    AnyCollectableVec, CollectableVec, Compressed, EagerVec, Result, StoredVec, Version,
+};
 
-use crate::storage::vecs::{Indexes, base::ComputedVec, indexes};
+use crate::storage::{Indexes, indexes};
 
 use super::{ComputedType, ComputedVecBuilder, StorableVecGeneatorOptions};
 
@@ -17,18 +19,20 @@ pub struct ComputedVecsFromTxindex<T>
 where
     T: ComputedType + PartialOrd,
 {
-    pub txindex: Option<ComputedVec<Txindex, T>>,
+    pub txindex: Option<EagerVec<TxIndex, T>>,
     pub height: ComputedVecBuilder<Height, T>,
-    pub dateindex: ComputedVecBuilder<Dateindex, T>,
-    pub weekindex: ComputedVecBuilder<Weekindex, T>,
-    pub difficultyepoch: ComputedVecBuilder<Difficultyepoch, T>,
-    pub monthindex: ComputedVecBuilder<Monthindex, T>,
-    pub quarterindex: ComputedVecBuilder<Quarterindex, T>,
-    pub yearindex: ComputedVecBuilder<Yearindex, T>,
+    pub dateindex: ComputedVecBuilder<DateIndex, T>,
+    pub weekindex: ComputedVecBuilder<WeekIndex, T>,
+    pub difficultyepoch: ComputedVecBuilder<DifficultyEpoch, T>,
+    pub monthindex: ComputedVecBuilder<MonthIndex, T>,
+    pub quarterindex: ComputedVecBuilder<QuarterIndex, T>,
+    pub yearindex: ComputedVecBuilder<YearIndex, T>,
     // TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
-    pub decadeindex: ComputedVecBuilder<Decadeindex, T>,
+    pub decadeindex: ComputedVecBuilder<DecadeIndex, T>,
 }
 
+const VERSION: Version = Version::ZERO;
+
 impl<T> ComputedVecsFromTxindex<T>
 where
     T: ComputedType + Ord + From<f64>,
@@ -42,8 +46,10 @@ where
         compressed: Compressed,
         options: StorableVecGeneatorOptions,
     ) -> color_eyre::Result<Self> {
+        let version = VERSION + version;
+
         let txindex = compute_source.then(|| {
-            ComputedVec::forced_import(
+            EagerVec::forced_import(
                 &path.join(format!("txindex_to_{name}")),
                 version,
                 compressed,
@@ -51,37 +57,46 @@ where
             .unwrap()
         });
 
-        let height = ComputedVecBuilder::forced_import(path, name, compressed, options)?;
+        let height = ComputedVecBuilder::forced_import(path, name, version, compressed, options)?;
 
         let options = options.remove_percentiles();
 
         Ok(Self {
             txindex,
             height,
-            dateindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            weekindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            difficultyepoch: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            monthindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            quarterindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            yearindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
-            // halvingepoch: StorableVecGeneator::forced_import(path, name, compressed, options)?,
-            decadeindex: ComputedVecBuilder::forced_import(path, name, compressed, options)?,
+            dateindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            weekindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            difficultyepoch: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            monthindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            quarterindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
+            yearindex: ComputedVecBuilder::forced_import(path, name, version, compressed, options)?,
+            // halvingepoch: StorableVecGeneator::forced_import(path, name, version, compressed, options)?,
+            decadeindex: ComputedVecBuilder::forced_import(
+                path, name, version, compressed, options,
+            )?,
         })
     }
 
+    #[allow(unused)]
     pub fn compute_all<F>(
         &mut self,
-        indexer: &mut Indexer,
-        indexes: &mut indexes::Vecs,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
         mut compute: F,
     ) -> color_eyre::Result<()>
     where
         F: FnMut(
-            &mut ComputedVec<Txindex, T>,
-            &mut Indexer,
-            &mut indexes::Vecs,
+            &mut EagerVec<TxIndex, T>,
+            &Indexer,
+            &indexes::Vecs,
             &Indexes,
             &Exit,
         ) -> Result<()>,
@@ -94,100 +109,113 @@ where
             exit,
         )?;
 
-        self.compute_rest(indexer, indexes, starting_indexes, exit, None)?;
+        let txindex: Option<&StoredVec<TxIndex, T>> = None;
+        self.compute_rest(indexer, indexes, starting_indexes, exit, txindex)?;
 
         Ok(())
     }
 
     pub fn compute_rest(
         &mut self,
-        indexer: &mut Indexer,
-        indexes: &mut indexes::Vecs,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
-        txindex: Option<&mut StoredVec<Txindex, T>>,
+        txindex: Option<&impl CollectableVec<TxIndex, T>>,
     ) -> color_eyre::Result<()> {
-        let txindex = txindex.unwrap_or_else(|| self.txindex.as_mut().unwrap().mut_vec());
+        if let Some(txindex) = txindex {
+            self.height.compute(
+                starting_indexes.height,
+                txindex,
+                &indexer.vecs().height_to_first_txindex,
+                &indexes.height_to_txindex_count,
+                exit,
+            )?;
+        } else {
+            let txindex = self.txindex.as_ref().unwrap();
 
-        self.height.compute(
-            starting_indexes.height,
-            txindex,
-            indexer.mut_vecs().height_to_first_txindex.mut_vec(),
-            indexes.height_to_last_txindex.mut_vec(),
-            exit,
-        )?;
+            self.height.compute(
+                starting_indexes.height,
+                txindex,
+                &indexer.vecs().height_to_first_txindex,
+                &indexes.height_to_txindex_count,
+                exit,
+            )?;
+        }
 
         self.dateindex.from_aligned(
             starting_indexes.dateindex,
-            &mut self.height,
-            indexes.dateindex_to_first_height.mut_vec(),
-            indexes.dateindex_to_last_height.mut_vec(),
+            &self.height,
+            &indexes.dateindex_to_first_height,
+            &indexes.dateindex_to_height_count,
             exit,
         )?;
 
         self.weekindex.from_aligned(
             starting_indexes.weekindex,
-            &mut self.dateindex,
-            indexes.weekindex_to_first_dateindex.mut_vec(),
-            indexes.weekindex_to_last_dateindex.mut_vec(),
+            &self.dateindex,
+            &indexes.weekindex_to_first_dateindex,
+            &indexes.weekindex_to_dateindex_count,
             exit,
         )?;
 
         self.monthindex.from_aligned(
             starting_indexes.monthindex,
-            &mut self.dateindex,
-            indexes.monthindex_to_first_dateindex.mut_vec(),
-            indexes.monthindex_to_last_dateindex.mut_vec(),
+            &self.dateindex,
+            &indexes.monthindex_to_first_dateindex,
+            &indexes.monthindex_to_dateindex_count,
             exit,
         )?;
 
         self.quarterindex.from_aligned(
             starting_indexes.quarterindex,
-            &mut self.monthindex,
-            indexes.quarterindex_to_first_monthindex.mut_vec(),
-            indexes.quarterindex_to_last_monthindex.mut_vec(),
+            &self.monthindex,
+            &indexes.quarterindex_to_first_monthindex,
+            &indexes.quarterindex_to_monthindex_count,
             exit,
         )?;
 
         self.yearindex.from_aligned(
             starting_indexes.yearindex,
-            &mut self.monthindex,
-            indexes.yearindex_to_first_monthindex.mut_vec(),
-            indexes.yearindex_to_last_monthindex.mut_vec(),
+            &self.monthindex,
+            &indexes.yearindex_to_first_monthindex,
+            &indexes.yearindex_to_monthindex_count,
             exit,
         )?;
 
         self.decadeindex.from_aligned(
             starting_indexes.decadeindex,
-            &mut self.yearindex,
-            indexes.decadeindex_to_first_yearindex.mut_vec(),
-            indexes.decadeindex_to_last_yearindex.mut_vec(),
+            &self.yearindex,
+            &indexes.decadeindex_to_first_yearindex,
+            &indexes.decadeindex_to_yearindex_count,
             exit,
         )?;
 
         self.difficultyepoch.from_aligned(
             starting_indexes.difficultyepoch,
-            &mut self.height,
-            indexes.difficultyepoch_to_first_height.mut_vec(),
-            indexes.difficultyepoch_to_last_height.mut_vec(),
+            &self.height,
+            &indexes.difficultyepoch_to_first_height,
+            &indexes.difficultyepoch_to_height_count,
             exit,
         )?;
 
         Ok(())
     }
 
-    pub fn any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         [
-            self.txindex.as_ref().map_or(vec![], |v| vec![v.any_vec()]),
-            self.height.any_vecs(),
-            self.dateindex.any_vecs(),
-            self.weekindex.any_vecs(),
-            self.difficultyepoch.any_vecs(),
-            self.monthindex.any_vecs(),
-            self.quarterindex.any_vecs(),
-            self.yearindex.any_vecs(),
-            // self.halvingepoch.as_any_vecs(),
-            self.decadeindex.any_vecs(),
+            self.txindex
+                .as_ref()
+                .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
+            self.height.vecs(),
+            self.dateindex.vecs(),
+            self.weekindex.vecs(),
+            self.difficultyepoch.vecs(),
+            self.monthindex.vecs(),
+            self.quarterindex.vecs(),
+            self.yearindex.vecs(),
+            // self.halvingepoch.vecs(),
+            self.decadeindex.vecs(),
         ]
         .concat()
     }

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

@@ -3,11 +3,15 @@ mod from_dateindex;
 mod from_height;
 mod from_height_strict;
 mod from_txindex;
-mod stored_type;
+mod r#type;
+mod value_from_height;
+mod value_from_txindex;
 
 pub use builder::*;
 pub use from_dateindex::*;
 pub use from_height::*;
 pub use from_height_strict::*;
 pub use from_txindex::*;
-pub use stored_type::*;
+use r#type::*;
+pub use value_from_height::*;
+pub use value_from_txindex::*;

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

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

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

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

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

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

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

@@ -0,0 +1,253 @@
+use std::{fs, path::Path};
+
+use brk_core::{Dollars, StoredF64, StoredUsize};
+use brk_exit::Exit;
+use brk_indexer::Indexer;
+use brk_vec::{AnyCollectableVec, Compressed, Computation, StoredIndex, VecIterator, Version};
+
+use super::{
+    Indexes, fetched,
+    grouped::{ComputedVecsFromDateindex, StorableVecGeneatorOptions},
+    indexes, transactions,
+};
+
+#[derive(Clone)]
+pub struct Vecs {
+    pub indexes_to_marketcap: ComputedVecsFromDateindex<Dollars>,
+    pub indexes_to_ath: ComputedVecsFromDateindex<Dollars>,
+    pub indexes_to_drawdown: ComputedVecsFromDateindex<StoredF64>,
+    pub indexes_to_days_since_ath: ComputedVecsFromDateindex<StoredUsize>,
+    pub indexes_to_max_days_between_ath: ComputedVecsFromDateindex<StoredUsize>,
+    pub indexes_to_max_years_between_ath: ComputedVecsFromDateindex<StoredF64>,
+}
+
+impl Vecs {
+    pub fn forced_import(
+        path: &Path,
+        _computation: Computation,
+        compressed: Compressed,
+    ) -> color_eyre::Result<Self> {
+        fs::create_dir_all(path)?;
+
+        Ok(Self {
+            indexes_to_marketcap: ComputedVecsFromDateindex::forced_import(
+                path,
+                "marketcap",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_ath: ComputedVecsFromDateindex::forced_import(
+                path,
+                "ath",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_drawdown: ComputedVecsFromDateindex::forced_import(
+                path,
+                "drawdown",
+                Version::ONE,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_days_since_ath: ComputedVecsFromDateindex::forced_import(
+                path,
+                "days_since_ath",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_max_days_between_ath: ComputedVecsFromDateindex::forced_import(
+                path,
+                "max_days_between_ath",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            indexes_to_max_years_between_ath: ComputedVecsFromDateindex::forced_import(
+                path,
+                "max_years_between_ath",
+                Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+        })
+    }
+
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        fetched: &fetched::Vecs,
+        transactions: &mut transactions::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> color_eyre::Result<()> {
+        self.indexes_to_marketcap.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                let mut total_subsidy_in_btc = transactions
+                    .indexes_to_subsidy
+                    .bitcoin
+                    .dateindex
+                    .unwrap_total()
+                    .into_iter();
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    &fetched.timeindexes_to_close.dateindex,
+                    |(i, close, ..)| {
+                        let supply = total_subsidy_in_btc.unwrap_get_inner(i);
+                        (i, *close * supply)
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_ath.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                let mut prev = None;
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    &fetched.timeindexes_to_high.dateindex,
+                    |(i, high, slf)| {
+                        if prev.is_none() {
+                            let i = i.unwrap_to_usize();
+                            prev.replace(if i > 0 {
+                                slf.into_iter().unwrap_get_inner_(i - 1)
+                            } else {
+                                Dollars::ZERO
+                            });
+                        }
+                        let ath = prev.unwrap().max(*high);
+                        prev.replace(ath);
+                        (i, ath)
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_drawdown.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                let mut close_iter = fetched.timeindexes_to_close.dateindex.into_iter();
+
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    &self.indexes_to_ath.dateindex,
+                    |(i, ath, ..)| {
+                        if ath == Dollars::ZERO {
+                            return (i, StoredF64::default());
+                        }
+                        let close = *close_iter.unwrap_get_inner(i);
+                        let drawdown = StoredF64::from((*ath - *close) / *ath * -100.0);
+                        (i, drawdown)
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_days_since_ath.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                let mut high_iter = fetched.timeindexes_to_high.dateindex.into_iter();
+                let mut prev = None;
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    &self.indexes_to_ath.dateindex,
+                    |(i, ath, slf)| {
+                        if prev.is_none() {
+                            let i = i.unwrap_to_usize();
+                            prev.replace(if i > 0 {
+                                slf.into_iter().unwrap_get_inner_(i - 1)
+                            } else {
+                                StoredUsize::default()
+                            });
+                        }
+                        let days = if *high_iter.unwrap_get_inner(i) == ath {
+                            StoredUsize::default()
+                        } else {
+                            prev.unwrap() + StoredUsize::from(1)
+                        };
+                        prev.replace(days);
+                        (i, days)
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_max_days_between_ath.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                let mut prev = None;
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    &self.indexes_to_days_since_ath.dateindex,
+                    |(i, days, slf)| {
+                        if prev.is_none() {
+                            let i = i.unwrap_to_usize();
+                            prev.replace(if i > 0 {
+                                slf.into_iter().unwrap_get_inner_(i - 1)
+                            } else {
+                                StoredUsize::ZERO
+                            });
+                        }
+                        let max = prev.unwrap().max(days);
+                        prev.replace(max);
+                        (i, max)
+                    },
+                    exit,
+                )
+            },
+        )?;
+
+        self.indexes_to_max_years_between_ath.compute(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            |v, _, _, starting_indexes, exit| {
+                v.compute_transform(
+                    starting_indexes.dateindex,
+                    &self.indexes_to_max_days_between_ath.dateindex,
+                    |(i, max, ..)| (i, StoredF64::from(*max as f64 / 365.0)),
+                    exit,
+                )
+            },
+        )?;
+
+        Ok(())
+    }
+
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
+        [
+            self.indexes_to_marketcap.vecs(),
+            self.indexes_to_ath.vecs(),
+            self.indexes_to_drawdown.vecs(),
+            self.indexes_to_days_since_ath.vecs(),
+            self.indexes_to_max_days_between_ath.vecs(),
+            self.indexes_to_max_years_between_ath.vecs(),
+        ]
+        .concat()
+    }
+}

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

@@ -1,804 +0,0 @@
-use std::{fs, path::Path};
-
-use brk_core::{
-    Cents, Close, Dateindex, Decadeindex, Difficultyepoch, Dollars, Height, High, Low, Monthindex,
-    OHLCCents, OHLCDollars, Open, Quarterindex, Sats, Weekindex, Yearindex,
-};
-use brk_exit::Exit;
-use brk_fetcher::Fetcher;
-use brk_indexer::Indexer;
-use brk_vec::{Compressed, Version};
-
-use super::{
-    ComputedVec, Indexes,
-    grouped::{
-        ComputedVecsFromDateindex, ComputedVecsFromHeightStrict, StorableVecGeneatorOptions,
-    },
-    indexes,
-};
-
-#[derive(Clone)]
-pub struct Vecs {
-    pub dateindex_to_close_in_cents: ComputedVec<Dateindex, Close<Cents>>,
-    pub dateindex_to_high_in_cents: ComputedVec<Dateindex, High<Cents>>,
-    pub dateindex_to_low_in_cents: ComputedVec<Dateindex, Low<Cents>>,
-    pub dateindex_to_ohlc: ComputedVec<Dateindex, OHLCDollars>,
-    pub dateindex_to_ohlc_in_cents: ComputedVec<Dateindex, OHLCCents>,
-    pub dateindex_to_open_in_cents: ComputedVec<Dateindex, Open<Cents>>,
-    pub height_to_close_in_cents: ComputedVec<Height, Close<Cents>>,
-    pub height_to_high_in_cents: ComputedVec<Height, High<Cents>>,
-    pub height_to_low_in_cents: ComputedVec<Height, Low<Cents>>,
-    pub height_to_ohlc: ComputedVec<Height, OHLCDollars>,
-    pub height_to_ohlc_in_cents: ComputedVec<Height, OHLCCents>,
-    pub height_to_open_in_cents: ComputedVec<Height, Open<Cents>>,
-    pub timeindexes_to_close: ComputedVecsFromDateindex<Close<Dollars>>,
-    pub timeindexes_to_high: ComputedVecsFromDateindex<High<Dollars>>,
-    pub timeindexes_to_low: ComputedVecsFromDateindex<Low<Dollars>>,
-    pub timeindexes_to_open: ComputedVecsFromDateindex<Open<Dollars>>,
-    pub timeindexes_to_sats_per_dollar: ComputedVecsFromDateindex<Close<Sats>>,
-    pub chainindexes_to_close: ComputedVecsFromHeightStrict<Close<Dollars>>,
-    pub chainindexes_to_high: ComputedVecsFromHeightStrict<High<Dollars>>,
-    pub chainindexes_to_low: ComputedVecsFromHeightStrict<Low<Dollars>>,
-    pub chainindexes_to_open: ComputedVecsFromHeightStrict<Open<Dollars>>,
-    pub chainindexes_to_sats_per_dollar: ComputedVecsFromHeightStrict<Close<Sats>>,
-    pub weekindex_to_ohlc: ComputedVec<Weekindex, OHLCDollars>,
-    pub difficultyepoch_to_ohlc: ComputedVec<Difficultyepoch, OHLCDollars>,
-    pub monthindex_to_ohlc: ComputedVec<Monthindex, OHLCDollars>,
-    pub quarterindex_to_ohlc: ComputedVec<Quarterindex, OHLCDollars>,
-    pub yearindex_to_ohlc: ComputedVec<Yearindex, OHLCDollars>,
-    // pub halvingepoch_to_ohlc: StorableVec<Halvingepoch, OHLCDollars>,
-    pub decadeindex_to_ohlc: ComputedVec<Decadeindex, OHLCDollars>,
-}
-
-impl Vecs {
-    pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
-        fs::create_dir_all(path)?;
-
-        let mut fetched_path = path.to_owned();
-        fetched_path.pop();
-        fetched_path.pop();
-        fetched_path = fetched_path.join("fetched/vecs");
-
-        Ok(Self {
-            dateindex_to_ohlc_in_cents: ComputedVec::forced_import(
-                &fetched_path.join("dateindex_to_ohlc_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_ohlc: ComputedVec::forced_import(
-                &path.join("dateindex_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_close_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_close_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_high_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_high_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_low_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_low_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            dateindex_to_open_in_cents: ComputedVec::forced_import(
-                &path.join("dateindex_to_open_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_ohlc_in_cents: ComputedVec::forced_import(
-                &fetched_path.join("height_to_ohlc_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_ohlc: ComputedVec::forced_import(
-                &path.join("height_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_close_in_cents: ComputedVec::forced_import(
-                &path.join("height_to_close_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_high_in_cents: ComputedVec::forced_import(
-                &path.join("height_to_high_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_low_in_cents: ComputedVec::forced_import(
-                &path.join("height_to_low_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_open_in_cents: ComputedVec::forced_import(
-                &path.join("height_to_open_in_cents"),
-                Version::ZERO,
-                compressed,
-            )?,
-            timeindexes_to_open: ComputedVecsFromDateindex::forced_import(
-                path,
-                "open",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_first(),
-            )?,
-            timeindexes_to_high: ComputedVecsFromDateindex::forced_import(
-                path,
-                "high",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_max(),
-            )?,
-            timeindexes_to_low: ComputedVecsFromDateindex::forced_import(
-                path,
-                "low",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_min(),
-            )?,
-            timeindexes_to_close: ComputedVecsFromDateindex::forced_import(
-                path,
-                "close",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_last(),
-            )?,
-            timeindexes_to_sats_per_dollar: ComputedVecsFromDateindex::forced_import(
-                path,
-                "sats_per_dollar",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_last(),
-            )?,
-            chainindexes_to_open: ComputedVecsFromHeightStrict::forced_import(
-                path,
-                "open",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_first(),
-            )?,
-            chainindexes_to_high: ComputedVecsFromHeightStrict::forced_import(
-                path,
-                "high",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_max(),
-            )?,
-            chainindexes_to_low: ComputedVecsFromHeightStrict::forced_import(
-                path,
-                "low",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_min(),
-            )?,
-            chainindexes_to_close: ComputedVecsFromHeightStrict::forced_import(
-                path,
-                "close",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_last(),
-            )?,
-            chainindexes_to_sats_per_dollar: ComputedVecsFromHeightStrict::forced_import(
-                path,
-                "sats_per_dollar",
-                Version::ZERO,
-                compressed,
-                StorableVecGeneatorOptions::default().add_last(),
-            )?,
-            weekindex_to_ohlc: ComputedVec::forced_import(
-                &path.join("weekindex_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-            difficultyepoch_to_ohlc: ComputedVec::forced_import(
-                &path.join("difficultyepoch_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-            monthindex_to_ohlc: ComputedVec::forced_import(
-                &path.join("monthindex_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-            quarterindex_to_ohlc: ComputedVec::forced_import(
-                &path.join("quarterindex_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-            yearindex_to_ohlc: ComputedVec::forced_import(
-                &path.join("yearindex_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-            // halvingepoch_to_ohlc: StorableVec::forced_import(&path.join("halvingepoch_to_ohlc"), Version::ZERO, compressed)?,
-            decadeindex_to_ohlc: ComputedVec::forced_import(
-                &path.join("decadeindex_to_ohlc"),
-                Version::ZERO,
-                compressed,
-            )?,
-        })
-    }
-
-    pub fn compute(
-        &mut self,
-        indexer: &mut Indexer,
-        indexes: &mut indexes::Vecs,
-        starting_indexes: &Indexes,
-        fetcher: &mut Fetcher,
-        exit: &Exit,
-    ) -> color_eyre::Result<()> {
-        let indexer_vecs = indexer.mut_vecs();
-
-        self.height_to_ohlc_in_cents.compute_transform(
-            starting_indexes.height,
-            indexer_vecs.height_to_timestamp.mut_vec(),
-            |(h, t, _, height_to_timestamp)| {
-                let ohlc = fetcher
-                    .get_height(
-                        h,
-                        t,
-                        h.decremented().map(|prev_h| {
-                            *height_to_timestamp.cached_get(prev_h).unwrap().unwrap()
-                        }),
-                    )
-                    .unwrap();
-                (h, ohlc)
-            },
-            exit,
-        )?;
-
-        self.height_to_open_in_cents.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.open),
-            exit,
-        )?;
-
-        self.height_to_high_in_cents.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.high),
-            exit,
-        )?;
-
-        self.height_to_low_in_cents.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.low),
-            exit,
-        )?;
-
-        self.height_to_close_in_cents.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.close),
-            exit,
-        )?;
-
-        self.height_to_ohlc.compute_transform(
-            starting_indexes.height,
-            self.height_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, OHLCDollars::from(ohlc)),
-            exit,
-        )?;
-
-        self.dateindex_to_ohlc_in_cents.compute_transform(
-            starting_indexes.dateindex,
-            indexes.dateindex_to_date.mut_vec(),
-            |(di, d, ..)| {
-                let ohlc = fetcher.get_date(d).unwrap();
-                (di, ohlc)
-            },
-            exit,
-        )?;
-
-        self.dateindex_to_open_in_cents.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.open),
-            exit,
-        )?;
-
-        self.dateindex_to_high_in_cents.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.high),
-            exit,
-        )?;
-
-        self.dateindex_to_low_in_cents.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.low),
-            exit,
-        )?;
-
-        self.dateindex_to_close_in_cents.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, ohlc.close),
-            exit,
-        )?;
-
-        self.dateindex_to_ohlc.compute_transform(
-            starting_indexes.dateindex,
-            self.dateindex_to_ohlc_in_cents.mut_vec(),
-            |(di, ohlc, ..)| (di, OHLCDollars::from(ohlc)),
-            exit,
-        )?;
-
-        self.timeindexes_to_close.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.dateindex,
-                    self.dateindex_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.close),
-                    exit,
-                )
-            },
-        )?;
-
-        self.timeindexes_to_high.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.dateindex,
-                    self.dateindex_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.high),
-                    exit,
-                )
-            },
-        )?;
-
-        self.timeindexes_to_low.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.dateindex,
-                    self.dateindex_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.low),
-                    exit,
-                )
-            },
-        )?;
-
-        self.timeindexes_to_open.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.dateindex,
-                    self.dateindex_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.open),
-                    exit,
-                )
-            },
-        )?;
-
-        self.chainindexes_to_close.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.height,
-                    self.height_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.close),
-                    exit,
-                )
-            },
-        )?;
-
-        self.chainindexes_to_high.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.height,
-                    self.height_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.high),
-                    exit,
-                )
-            },
-        )?;
-
-        self.chainindexes_to_low.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.height,
-                    self.height_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.low),
-                    exit,
-                )
-            },
-        )?;
-
-        self.chainindexes_to_open.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.height,
-                    self.height_to_ohlc.mut_vec(),
-                    |(di, ohlc, ..)| (di, ohlc.open),
-                    exit,
-                )
-            },
-        )?;
-
-        self.weekindex_to_ohlc.compute_transform(
-            starting_indexes.weekindex,
-            self.timeindexes_to_close
-                .weekindex
-                .last
-                .as_mut()
-                .unwrap()
-                .mut_vec(),
-            |(i, close, ..)| {
-                (
-                    i,
-                    OHLCDollars {
-                        open: *self
-                            .timeindexes_to_open
-                            .weekindex
-                            .first
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        high: *self
-                            .timeindexes_to_high
-                            .weekindex
-                            .max
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        low: *self
-                            .timeindexes_to_low
-                            .weekindex
-                            .min
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        close,
-                    },
-                )
-            },
-            exit,
-        )?;
-
-        self.difficultyepoch_to_ohlc.compute_transform(
-            starting_indexes.difficultyepoch,
-            self.chainindexes_to_close
-                .difficultyepoch
-                .last
-                .as_mut()
-                .unwrap()
-                .mut_vec(),
-            |(i, close, ..)| {
-                (
-                    i,
-                    OHLCDollars {
-                        open: *self
-                            .chainindexes_to_open
-                            .difficultyepoch
-                            .first
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        high: *self
-                            .chainindexes_to_high
-                            .difficultyepoch
-                            .max
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        low: *self
-                            .chainindexes_to_low
-                            .difficultyepoch
-                            .min
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        close,
-                    },
-                )
-            },
-            exit,
-        )?;
-
-        self.monthindex_to_ohlc.compute_transform(
-            starting_indexes.monthindex,
-            self.timeindexes_to_close
-                .monthindex
-                .last
-                .as_mut()
-                .unwrap()
-                .mut_vec(),
-            |(i, close, ..)| {
-                (
-                    i,
-                    OHLCDollars {
-                        open: *self
-                            .timeindexes_to_open
-                            .monthindex
-                            .first
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        high: *self
-                            .timeindexes_to_high
-                            .monthindex
-                            .max
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        low: *self
-                            .timeindexes_to_low
-                            .monthindex
-                            .min
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        close,
-                    },
-                )
-            },
-            exit,
-        )?;
-
-        self.quarterindex_to_ohlc.compute_transform(
-            starting_indexes.quarterindex,
-            self.timeindexes_to_close
-                .quarterindex
-                .last
-                .as_mut()
-                .unwrap()
-                .mut_vec(),
-            |(i, close, ..)| {
-                (
-                    i,
-                    OHLCDollars {
-                        open: *self
-                            .timeindexes_to_open
-                            .quarterindex
-                            .first
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        high: *self
-                            .timeindexes_to_high
-                            .quarterindex
-                            .max
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        low: *self
-                            .timeindexes_to_low
-                            .quarterindex
-                            .min
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        close,
-                    },
-                )
-            },
-            exit,
-        )?;
-
-        self.yearindex_to_ohlc.compute_transform(
-            starting_indexes.yearindex,
-            self.timeindexes_to_close
-                .yearindex
-                .last
-                .as_mut()
-                .unwrap()
-                .mut_vec(),
-            |(i, close, ..)| {
-                (
-                    i,
-                    OHLCDollars {
-                        open: *self
-                            .timeindexes_to_open
-                            .yearindex
-                            .first
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        high: *self
-                            .timeindexes_to_high
-                            .yearindex
-                            .max
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        low: *self
-                            .timeindexes_to_low
-                            .yearindex
-                            .min
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        close,
-                    },
-                )
-            },
-            exit,
-        )?;
-
-        // self.halvingepoch_to_ohlc
-        //     .compute_transform(starting_indexes.halvingepoch, other, t, exit)?;
-
-        self.decadeindex_to_ohlc.compute_transform(
-            starting_indexes.decadeindex,
-            self.timeindexes_to_close
-                .decadeindex
-                .last
-                .as_mut()
-                .as_mut()
-                .unwrap()
-                .mut_vec(),
-            |(i, close, ..)| {
-                (
-                    i,
-                    OHLCDollars {
-                        open: *self
-                            .timeindexes_to_open
-                            .decadeindex
-                            .first
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        high: *self
-                            .timeindexes_to_high
-                            .decadeindex
-                            .max
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        low: *self
-                            .timeindexes_to_low
-                            .decadeindex
-                            .min
-                            .as_mut()
-                            .unwrap()
-                            .cached_get(i)
-                            .unwrap()
-                            .unwrap(),
-                        close,
-                    },
-                )
-            },
-            exit,
-        )?;
-
-        self.chainindexes_to_sats_per_dollar.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.height,
-                    self.chainindexes_to_close.height.mut_vec(),
-                    |(i, close, ..)| (i, Close::from(Sats::ONE_BTC / *close)),
-                    exit,
-                )
-            },
-        )?;
-
-        self.timeindexes_to_sats_per_dollar.compute(
-            indexer,
-            indexes,
-            starting_indexes,
-            exit,
-            |v, _, _, starting_indexes, exit| {
-                v.compute_transform(
-                    starting_indexes.dateindex,
-                    self.timeindexes_to_close.dateindex.mut_vec(),
-                    |(i, close, ..)| (i, Close::from(Sats::ONE_BTC / *close)),
-                    exit,
-                )
-            },
-        )?;
-
-        Ok(())
-    }
-
-    pub fn as_any_vecs(&self) -> Vec<&dyn brk_vec::AnyStoredVec> {
-        vec![
-            vec![
-                self.dateindex_to_close_in_cents.any_vec(),
-                self.dateindex_to_high_in_cents.any_vec(),
-                self.dateindex_to_low_in_cents.any_vec(),
-                self.dateindex_to_ohlc.any_vec(),
-                self.dateindex_to_ohlc_in_cents.any_vec(),
-                self.dateindex_to_open_in_cents.any_vec(),
-                self.height_to_close_in_cents.any_vec(),
-                self.height_to_high_in_cents.any_vec(),
-                self.height_to_low_in_cents.any_vec(),
-                self.height_to_ohlc.any_vec(),
-                self.height_to_ohlc_in_cents.any_vec(),
-                self.height_to_open_in_cents.any_vec(),
-                self.weekindex_to_ohlc.any_vec(),
-                self.difficultyepoch_to_ohlc.any_vec(),
-                self.monthindex_to_ohlc.any_vec(),
-                self.quarterindex_to_ohlc.any_vec(),
-                self.yearindex_to_ohlc.any_vec(),
-                // self.halvingepoch_to_ohlc.any_vec(),
-                self.decadeindex_to_ohlc.any_vec(),
-            ],
-            self.chainindexes_to_sats_per_dollar.any_vecs(),
-            self.timeindexes_to_sats_per_dollar.any_vecs(),
-            self.timeindexes_to_close.any_vecs(),
-            self.timeindexes_to_high.any_vecs(),
-            self.timeindexes_to_low.any_vecs(),
-            self.timeindexes_to_open.any_vecs(),
-            self.chainindexes_to_close.any_vecs(),
-            self.chainindexes_to_high.any_vecs(),
-            self.chainindexes_to_low.any_vecs(),
-            self.chainindexes_to_open.any_vecs(),
-        ]
-        .concat()
-    }
-}

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

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

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

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

crates/brk_core/Cargo.toml

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

crates/brk_core/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_core/src/structs/_addressindex.rs

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

crates/brk_core/src/structs/_addressindexoutputindex.rs

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

crates/brk_core/src/structs/_addresstype.rs

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

crates/brk_core/src/structs/addressbytes.rs

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

crates/brk_core/src/structs/addressbyteshash.rs

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

crates/brk_core/src/structs/addressindextxoutindex.rs

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

crates/brk_core/src/structs/addresstypeindex.rs

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

crates/brk_core/src/structs/bitcoin.rs

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

crates/brk_core/src/structs/blockhash.rs

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

crates/brk_core/src/structs/blockhashprefix.rs

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

crates/brk_core/src/structs/cents.rs

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

crates/brk_core/src/structs/compressed.rs

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

crates/brk_core/src/structs/date.rs

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

crates/brk_core/src/structs/dateindex.rs

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

crates/brk_core/src/structs/decadeindex.rs

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

crates/brk_core/src/structs/difficultyepoch.rs

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

crates/brk_core/src/structs/dollars.rs

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

crates/brk_core/src/structs/feerate.rs

@@ -1,7 +1,7 @@
 use std::ops::{Add, Div};
 
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::{Sats, StoredUsize};
 

crates/brk_core/src/structs/halvingepoch.rs

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

crates/brk_core/src/structs/height.rs

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

crates/brk_core/src/structs/inputindex.rs

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

crates/brk_core/src/structs/locktime.rs

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

crates/brk_core/src/structs/mod.rs

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

crates/brk_core/src/structs/monthindex.rs

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

crates/brk_core/src/structs/ohlc.rs

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

crates/brk_core/src/structs/outputindex.rs

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

crates/brk_core/src/structs/outputtype.rs

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

crates/brk_core/src/structs/outputtypeindex.rs

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

crates/brk_core/src/structs/quarterindex.rs

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

crates/brk_core/src/structs/rawlocktime.rs

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

crates/brk_core/src/structs/sats.rs

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

crates/brk_core/src/structs/stored_f64.rs

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

crates/brk_core/src/structs/stored_u32.rs

@@ -2,10 +2,15 @@ use std::ops::{Add, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
+use super::{
+    EmptyOutputIndex, OpReturnIndex, P2AIndex, P2MSIndex, P2PK33Index, P2PK65Index, P2PKHIndex,
+    P2SHIndex, P2TRIndex, P2WPKHIndex, P2WSHIndex, UnknownOutputIndex,
+};
+
 #[derive(
     Debug,
     Deref,
@@ -39,6 +44,9 @@ impl From<u32> for StoredU32 {
 
 impl From<usize> for StoredU32 {
     fn from(value: usize) -> Self {
+        if value > u32::MAX as usize {
+            panic!("usize too big (value = {value})")
+        }
         Self(value as u32)
     }
 }
@@ -77,3 +85,81 @@ impl From<StoredU32> for f64 {
         value.0 as f64
     }
 }
+
+impl From<StoredU32> for usize {
+    fn from(value: StoredU32) -> Self {
+        value.0 as usize
+    }
+}
+
+impl From<P2PK65Index> for StoredU32 {
+    fn from(value: P2PK65Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PK33Index> for StoredU32 {
+    fn from(value: P2PK33Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PKHIndex> for StoredU32 {
+    fn from(value: P2PKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<OpReturnIndex> for StoredU32 {
+    fn from(value: OpReturnIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2MSIndex> for StoredU32 {
+    fn from(value: P2MSIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2SHIndex> for StoredU32 {
+    fn from(value: P2SHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WSHIndex> for StoredU32 {
+    fn from(value: P2WSHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WPKHIndex> for StoredU32 {
+    fn from(value: P2WPKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2TRIndex> for StoredU32 {
+    fn from(value: P2TRIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2AIndex> for StoredU32 {
+    fn from(value: P2AIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<UnknownOutputIndex> for StoredU32 {
+    fn from(value: UnknownOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<EmptyOutputIndex> for StoredU32 {
+    fn from(value: EmptyOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}

crates/brk_core/src/structs/stored_u64.rs

@@ -2,11 +2,11 @@ use std::ops::{Add, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
-use super::{Txindex, Txinindex, Txoutindex};
+use super::{InputIndex, OutputIndex, TxIndex};
 
 #[derive(
     Debug,
@@ -80,20 +80,20 @@ impl From<StoredU64> for f64 {
     }
 }
 
-impl From<Txindex> for StoredU64 {
-    fn from(value: Txindex) -> Self {
+impl From<TxIndex> for StoredU64 {
+    fn from(value: TxIndex) -> Self {
         Self(*value as u64)
     }
 }
 
-impl From<Txinindex> for StoredU64 {
-    fn from(value: Txinindex) -> Self {
+impl From<InputIndex> for StoredU64 {
+    fn from(value: InputIndex) -> Self {
         Self(*value)
     }
 }
 
-impl From<Txoutindex> for StoredU64 {
-    fn from(value: Txoutindex) -> Self {
+impl From<OutputIndex> for StoredU64 {
+    fn from(value: OutputIndex) -> Self {
         Self(*value)
     }
 }

crates/brk_core/src/structs/stored_u8.rs

@@ -2,11 +2,14 @@ use std::ops::{Add, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
+pub type StoredPhantom = StoredU8;
+
 #[derive(
+    Default,
     Debug,
     Deref,
     Clone,
@@ -77,3 +80,16 @@ impl From<StoredU8> for f64 {
         value.0 as f64
     }
 }
+
+impl Add<usize> for StoredU8 {
+    type Output = Self;
+    fn add(self, rhs: usize) -> Self::Output {
+        Self(self.0.checked_add(rhs as u8).unwrap())
+    }
+}
+
+impl From<StoredU8> for usize {
+    fn from(value: StoredU8) -> Self {
+        value.0 as usize
+    }
+}

crates/brk_core/src/structs/stored_usize.rs

@@ -2,14 +2,21 @@ use std::ops::{Add, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use crate::CheckedSub;
 
+use super::{
+    DateIndex, EmptyOutputIndex, Height, InputIndex, MonthIndex, OpReturnIndex, OutputIndex,
+    P2AIndex, P2MSIndex, P2PK33Index, P2PK65Index, P2PKHIndex, P2SHIndex, P2TRIndex, P2WPKHIndex,
+    P2WSHIndex, TxIndex, UnknownOutputIndex, YearIndex,
+};
+
 #[derive(
     Debug,
     Deref,
     Clone,
+    Default,
     Copy,
     PartialEq,
     Eq,
@@ -71,3 +78,117 @@ impl From<StoredUsize> for f64 {
         value.0 as f64
     }
 }
+
+impl From<Height> for StoredUsize {
+    fn from(value: Height) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<DateIndex> for StoredUsize {
+    fn from(value: DateIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<MonthIndex> for StoredUsize {
+    fn from(value: MonthIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<YearIndex> for StoredUsize {
+    fn from(value: YearIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<OutputIndex> for StoredUsize {
+    fn from(value: OutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<InputIndex> for StoredUsize {
+    fn from(value: InputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<TxIndex> for StoredUsize {
+    fn from(value: TxIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PK65Index> for StoredUsize {
+    fn from(value: P2PK65Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PK33Index> for StoredUsize {
+    fn from(value: P2PK33Index) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2PKHIndex> for StoredUsize {
+    fn from(value: P2PKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<OpReturnIndex> for StoredUsize {
+    fn from(value: OpReturnIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2MSIndex> for StoredUsize {
+    fn from(value: P2MSIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2SHIndex> for StoredUsize {
+    fn from(value: P2SHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WSHIndex> for StoredUsize {
+    fn from(value: P2WSHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2WPKHIndex> for StoredUsize {
+    fn from(value: P2WPKHIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2TRIndex> for StoredUsize {
+    fn from(value: P2TRIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<P2AIndex> for StoredUsize {
+    fn from(value: P2AIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<UnknownOutputIndex> for StoredUsize {
+    fn from(value: UnknownOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}
+
+impl From<EmptyOutputIndex> for StoredUsize {
+    fn from(value: EmptyOutputIndex) -> Self {
+        Self::from(usize::from(value))
+    }
+}

crates/brk_core/src/structs/timestamp.rs

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

crates/brk_core/src/structs/txid.rs

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

crates/brk_core/src/structs/txidprefix.rs

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

crates/brk_core/src/structs/txindex.rs

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

crates/brk_core/src/structs/txversion.rs

@@ -1,6 +1,6 @@
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 use super::StoredU8;
 
@@ -19,28 +19,34 @@ use super::StoredU8;
     FromBytes,
     Serialize,
 )]
-pub struct TxVersion(i32);
+pub struct TxVersion(u8);
 
 impl TxVersion {
     pub const ONE: Self = Self(1);
     pub const TWO: Self = Self(2);
     pub const THREE: Self = Self(3);
+    pub const NON_STANDARD: Self = Self(u8::MAX);
 }
 
 impl From<bitcoin::transaction::Version> for TxVersion {
     fn from(value: bitcoin::transaction::Version) -> Self {
-        Self(value.0)
+        match value.0 {
+            1 => Self::ONE,
+            2 => Self::TWO,
+            3 => Self::THREE,
+            _ => Self::NON_STANDARD,
+        }
     }
 }
 
 impl From<TxVersion> for bitcoin::transaction::Version {
     fn from(value: TxVersion) -> Self {
-        Self(value.0)
+        Self(value.0 as i32)
     }
 }
 
 impl From<TxVersion> for StoredU8 {
     fn from(value: TxVersion) -> Self {
-        Self::from(value.0 as u8)
+        Self::from(value.0)
     }
 }

crates/brk_core/src/structs/weekindex.rs

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

crates/brk_core/src/structs/weight.rs

@@ -2,7 +2,7 @@ use std::ops::{Add, Div};
 
 use derive_deref::Deref;
 use serde::Serialize;
-use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 #[derive(
     Debug,
@@ -29,7 +29,7 @@ impl From<bitcoin::Weight> for Weight {
 
 impl From<Weight> for bitcoin::Weight {
     fn from(value: Weight) -> Self {
-        Self::from_wu(*value)
+        Self::from_wu(value.0)
     }
 }
 
@@ -64,3 +64,10 @@ impl Div<usize> for Weight {
         Self::from(self.0 as usize / rhs)
     }
 }
+
+impl Div<Weight> for Weight {
+    type Output = Self;
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
+    }
+}

crates/brk_core/src/structs/yearindex.rs

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

crates/brk_core/src/utils/bytes.rs

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

crates/brk_core/src/utils/mod.rs

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

crates/brk_exit/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_fetcher/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_fetcher/src/fetchers/binance.rs

@@ -223,10 +223,10 @@ impl Binance {
         Ok((
             timestamp,
             OHLCCents::from((
-                Open::from(get_cents(1)),
-                High::from(get_cents(2)),
-                Low::from(get_cents(3)),
-                Close::from(get_cents(4)),
+                Open::new(get_cents(1)),
+                High::new(get_cents(2)),
+                Low::new(get_cents(3)),
+                Close::new(get_cents(4)),
             )),
         ))
     }

crates/brk_fetcher/src/fetchers/kibo.rs

@@ -141,10 +141,10 @@ impl Kibo {
         };
 
         Ok(OHLCCents::from((
-            Open::from(get_value("open")?),
-            High::from(get_value("high")?),
-            Low::from(get_value("low")?),
-            Close::from(get_value("close")?),
+            Open::new(get_value("open")?),
+            High::new(get_value("high")?),
+            Low::new(get_value("low")?),
+            Close::new(get_value("close")?),
         )))
     }
 }

crates/brk_fetcher/src/fetchers/kraken.rs

@@ -114,10 +114,10 @@ impl Kraken {
         Ok((
             timestamp,
             OHLCCents::from((
-                Open::from(get_cents(1)),
-                High::from(get_cents(2)),
-                Low::from(get_cents(3)),
-                Close::from(get_cents(4)),
+                Open::new(get_cents(1)),
+                High::new(get_cents(2)),
+                Low::new(get_cents(3)),
+                Close::new(get_cents(4)),
             )),
         ))
     }

crates/brk_fetcher/src/lib.rs

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

crates/brk_indexer/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>
@@ -58,10 +58,9 @@ Stores: `src/storage/stores/mod.rs`
 
 ## Benchmark
 
-### Result 1 - 2025-04-12
+### `v0.0.21`
 
-- version: `v0.0.21`
-- machine: `Macbook Pro M3 Pro (36GB RAM)`
+- machine: `MBP M3 Pro (36GB RAM)`
 - mode: `raw`
 - from: `0`
 - to: `892_098`
@@ -69,3 +68,11 @@ Stores: `src/storage/stores/mod.rs`
 - peak memory: `6.1GB`
 - disk usage: `270 GB`
 - overhead: `36%` (`270 GB / 741 GB`)
+
+### `v0.0.31`
+
+- machine: `MBP M3 Pro (36GB RAM)`
+- mode: `raw`
+- disk usage: `208 GB`
+- overhead: `28%` (`208 GB / 744 GB`)
+- peak memory: `5.7GB`

crates/brk_indexer/examples/main.rs

@@ -24,7 +24,7 @@ fn main() -> color_eyre::Result<()> {
 
     let outputs = Path::new("../../_outputs");
 
-    let mut indexer = Indexer::new(outputs.join("indexed").to_owned(), true, true)?;
+    let mut indexer = Indexer::new(outputs, false, false)?;
 
     indexer.import_stores()?;
     indexer.import_vecs()?;

crates/brk_indexer/src/indexes.rs

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

crates/brk_indexer/src/lib.rs

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

crates/brk_indexer/src/stores/base.rs

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

crates/brk_indexer/src/stores/meta.rs

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

crates/brk_indexer/src/stores/mod.rs

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

crates/brk_indexer/src/vecs/mod.rs

@@ -1,100 +1,74 @@
 use std::{fs, path::Path};
 
 use brk_core::{
-    Addressbytes, Addressindex, Addresstype, Addresstypeindex, BlockHash, Emptyindex, Height,
-    LockTime, Multisigindex, Opreturnindex, P2PK33AddressBytes, P2PK33index, P2PK65AddressBytes,
-    P2PK65index, P2PKHAddressBytes, P2PKHindex, P2SHAddressBytes, P2SHindex, P2TRAddressBytes,
-    P2TRindex, P2WPKHAddressBytes, P2WPKHindex, P2WSHAddressBytes, P2WSHindex, Pushonlyindex, Sats,
-    StoredUsize, Timestamp, TxVersion, Txid, Txindex, Txinindex, Txoutindex, Unknownindex, Weight,
+    AddressBytes, BlockHash, EmptyOutputIndex, Height, InputIndex, OpReturnIndex, OutputIndex,
+    OutputType, OutputTypeIndex, P2ABytes, P2AIndex, P2MSIndex, P2PK33Bytes, P2PK33Index,
+    P2PK65Bytes, P2PK65Index, P2PKHBytes, P2PKHIndex, P2SHBytes, P2SHIndex, P2TRBytes, P2TRIndex,
+    P2WPKHBytes, P2WPKHIndex, P2WSHBytes, P2WSHIndex, RawLockTime, Sats, StoredF64, StoredU32,
+    StoredUsize, Timestamp, TxIndex, TxVersion, Txid, UnknownOutputIndex, Weight,
 };
-use brk_vec::{AnyStoredVec, Compressed, Result, Version};
+use brk_vec::{AnyCollectableVec, AnyIndexedVec, Compressed, IndexedVec, Result, Version};
 use rayon::prelude::*;
 
 use crate::Indexes;
 
-mod base;
-
-pub use base::*;
-
 #[derive(Clone)]
 pub struct Vecs {
-    pub addressindex_to_addresstype: IndexedVec<Addressindex, Addresstype>,
-    pub addressindex_to_addresstypeindex: IndexedVec<Addressindex, Addresstypeindex>,
-    pub addressindex_to_height: IndexedVec<Addressindex, Height>,
-    pub emptyindex_to_height: IndexedVec<Emptyindex, Height>,
+    pub emptyoutputindex_to_txindex: IndexedVec<EmptyOutputIndex, TxIndex>,
     pub height_to_blockhash: IndexedVec<Height, BlockHash>,
-    pub height_to_difficulty: IndexedVec<Height, f64>,
-    pub height_to_first_addressindex: IndexedVec<Height, Addressindex>,
-    pub height_to_first_emptyindex: IndexedVec<Height, Emptyindex>,
-    pub height_to_first_multisigindex: IndexedVec<Height, Multisigindex>,
-    pub height_to_first_opreturnindex: IndexedVec<Height, Opreturnindex>,
-    pub height_to_first_p2pk33index: IndexedVec<Height, P2PK33index>,
-    pub height_to_first_p2pk65index: IndexedVec<Height, P2PK65index>,
-    pub height_to_first_p2pkhindex: IndexedVec<Height, P2PKHindex>,
-    pub height_to_first_p2shindex: IndexedVec<Height, P2SHindex>,
-    pub height_to_first_p2trindex: IndexedVec<Height, P2TRindex>,
-    pub height_to_first_p2wpkhindex: IndexedVec<Height, P2WPKHindex>,
-    pub height_to_first_p2wshindex: IndexedVec<Height, P2WSHindex>,
-    pub height_to_first_pushonlyindex: IndexedVec<Height, Pushonlyindex>,
-    pub height_to_first_txindex: IndexedVec<Height, Txindex>,
-    pub height_to_first_txinindex: IndexedVec<Height, Txinindex>,
-    pub height_to_first_txoutindex: IndexedVec<Height, Txoutindex>,
-    pub height_to_first_unknownindex: IndexedVec<Height, Unknownindex>,
-    pub height_to_total_size: IndexedVec<Height, StoredUsize>,
+    pub height_to_difficulty: IndexedVec<Height, StoredF64>,
+    pub height_to_first_emptyoutputindex: IndexedVec<Height, EmptyOutputIndex>,
+    pub height_to_first_inputindex: IndexedVec<Height, InputIndex>,
+    pub height_to_first_opreturnindex: IndexedVec<Height, OpReturnIndex>,
+    pub height_to_first_outputindex: IndexedVec<Height, OutputIndex>,
+    pub height_to_first_p2aindex: IndexedVec<Height, P2AIndex>,
+    pub height_to_first_p2msindex: IndexedVec<Height, P2MSIndex>,
+    pub height_to_first_p2pk33index: IndexedVec<Height, P2PK33Index>,
+    pub height_to_first_p2pk65index: IndexedVec<Height, P2PK65Index>,
+    pub height_to_first_p2pkhindex: IndexedVec<Height, P2PKHIndex>,
+    pub height_to_first_p2shindex: IndexedVec<Height, P2SHIndex>,
+    pub height_to_first_p2trindex: IndexedVec<Height, P2TRIndex>,
+    pub height_to_first_p2wpkhindex: IndexedVec<Height, P2WPKHIndex>,
+    pub height_to_first_p2wshindex: IndexedVec<Height, P2WSHIndex>,
+    pub height_to_first_txindex: IndexedVec<Height, TxIndex>,
+    pub height_to_first_unknownoutputindex: IndexedVec<Height, UnknownOutputIndex>,
+    /// Doesn't guarantee continuity due to possible reorgs
     pub height_to_timestamp: IndexedVec<Height, Timestamp>,
+    pub height_to_total_size: IndexedVec<Height, StoredUsize>,
     pub height_to_weight: IndexedVec<Height, Weight>,
-    pub multisigindex_to_height: IndexedVec<Multisigindex, Height>,
-    pub opreturnindex_to_height: IndexedVec<Opreturnindex, Height>,
-    pub p2pk33index_to_height: IndexedVec<P2PK33index, Height>,
-    pub p2pk33index_to_p2pk33addressbytes: IndexedVec<P2PK33index, P2PK33AddressBytes>,
-    pub p2pk65index_to_height: IndexedVec<P2PK65index, Height>,
-    pub p2pk65index_to_p2pk65addressbytes: IndexedVec<P2PK65index, P2PK65AddressBytes>,
-    pub p2pkhindex_to_height: IndexedVec<P2PKHindex, Height>,
-    pub p2pkhindex_to_p2pkhaddressbytes: IndexedVec<P2PKHindex, P2PKHAddressBytes>,
-    pub p2shindex_to_height: IndexedVec<P2SHindex, Height>,
-    pub p2shindex_to_p2shaddressbytes: IndexedVec<P2SHindex, P2SHAddressBytes>,
-    pub p2trindex_to_height: IndexedVec<P2TRindex, Height>,
-    pub p2trindex_to_p2traddressbytes: IndexedVec<P2TRindex, P2TRAddressBytes>,
-    pub p2wpkhindex_to_height: IndexedVec<P2WPKHindex, Height>,
-    pub p2wpkhindex_to_p2wpkhaddressbytes: IndexedVec<P2WPKHindex, P2WPKHAddressBytes>,
-    pub p2wshindex_to_height: IndexedVec<P2WSHindex, Height>,
-    pub p2wshindex_to_p2wshaddressbytes: IndexedVec<P2WSHindex, P2WSHAddressBytes>,
-    pub pushonlyindex_to_height: IndexedVec<Pushonlyindex, Height>,
-    pub txindex_to_base_size: IndexedVec<Txindex, usize>,
-    pub txindex_to_first_txinindex: IndexedVec<Txindex, Txinindex>,
-    pub txindex_to_first_txoutindex: IndexedVec<Txindex, Txoutindex>,
-    pub txindex_to_height: IndexedVec<Txindex, Height>,
-    pub txindex_to_is_explicitly_rbf: IndexedVec<Txindex, bool>,
-    pub txindex_to_locktime: IndexedVec<Txindex, LockTime>,
-    pub txindex_to_total_size: IndexedVec<Txindex, usize>,
-    pub txindex_to_txid: IndexedVec<Txindex, Txid>,
-    pub txindex_to_txversion: IndexedVec<Txindex, TxVersion>,
-    pub txinindex_to_height: IndexedVec<Txinindex, Height>,
-    /// If txoutindex == Txoutindex MAX then is it's coinbase
-    pub txinindex_to_txoutindex: IndexedVec<Txinindex, Txoutindex>,
-    pub txoutindex_to_addressindex: IndexedVec<Txoutindex, Addressindex>,
-    pub txoutindex_to_height: IndexedVec<Txoutindex, Height>,
-    pub txoutindex_to_value: IndexedVec<Txoutindex, Sats>,
-    pub unknownindex_to_height: IndexedVec<Unknownindex, Height>,
+    /// If outputindex == Outputindex::MAX then it's coinbase
+    pub inputindex_to_outputindex: IndexedVec<InputIndex, OutputIndex>,
+    pub opreturnindex_to_txindex: IndexedVec<OpReturnIndex, TxIndex>,
+    pub outputindex_to_outputtype: IndexedVec<OutputIndex, OutputType>,
+    pub outputindex_to_outputtypeindex: IndexedVec<OutputIndex, OutputTypeIndex>,
+    pub outputindex_to_value: IndexedVec<OutputIndex, Sats>,
+    pub p2aindex_to_p2abytes: IndexedVec<P2AIndex, P2ABytes>,
+    pub p2msindex_to_txindex: IndexedVec<P2MSIndex, TxIndex>,
+    pub p2pk33index_to_p2pk33bytes: IndexedVec<P2PK33Index, P2PK33Bytes>,
+    pub p2pk65index_to_p2pk65bytes: IndexedVec<P2PK65Index, P2PK65Bytes>,
+    pub p2pkhindex_to_p2pkhbytes: IndexedVec<P2PKHIndex, P2PKHBytes>,
+    pub p2shindex_to_p2shbytes: IndexedVec<P2SHIndex, P2SHBytes>,
+    pub p2trindex_to_p2trbytes: IndexedVec<P2TRIndex, P2TRBytes>,
+    pub p2wpkhindex_to_p2wpkhbytes: IndexedVec<P2WPKHIndex, P2WPKHBytes>,
+    pub p2wshindex_to_p2wshbytes: IndexedVec<P2WSHIndex, P2WSHBytes>,
+    pub txindex_to_base_size: IndexedVec<TxIndex, StoredU32>,
+    pub txindex_to_first_inputindex: IndexedVec<TxIndex, InputIndex>,
+    pub txindex_to_first_outputindex: IndexedVec<TxIndex, OutputIndex>,
+    pub txindex_to_is_explicitly_rbf: IndexedVec<TxIndex, bool>,
+    pub txindex_to_rawlocktime: IndexedVec<TxIndex, RawLockTime>,
+    pub txindex_to_total_size: IndexedVec<TxIndex, StoredU32>,
+    pub txindex_to_txid: IndexedVec<TxIndex, Txid>,
+    pub txindex_to_txversion: IndexedVec<TxIndex, TxVersion>,
+    pub unknownoutputindex_to_txindex: IndexedVec<UnknownOutputIndex, TxIndex>,
 }
 
 impl Vecs {
-    pub fn import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
+    pub fn forced_import(path: &Path, compressed: Compressed) -> color_eyre::Result<Self> {
         fs::create_dir_all(path)?;
 
         Ok(Self {
-            addressindex_to_addresstype: IndexedVec::forced_import(
-                &path.join("addressindex_to_addresstype"),
-                Version::ZERO,
-                compressed,
-            )?,
-            addressindex_to_addresstypeindex: IndexedVec::forced_import(
-                &path.join("addressindex_to_addresstypeindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            addressindex_to_height: IndexedVec::forced_import(
-                &path.join("addressindex_to_height"),
+            emptyoutputindex_to_txindex: IndexedVec::forced_import(
+                &path.join("emptyoutputindex_to_txindex"),
                 Version::ZERO,
                 compressed,
             )?,
@@ -108,18 +82,13 @@ impl Vecs {
                 Version::ZERO,
                 compressed,
             )?,
-            height_to_first_addressindex: IndexedVec::forced_import(
-                &path.join("height_to_first_addressindex"),
+            height_to_first_emptyoutputindex: IndexedVec::forced_import(
+                &path.join("height_to_first_emptyoutputindex"),
                 Version::ZERO,
                 compressed,
             )?,
-            height_to_first_emptyindex: IndexedVec::forced_import(
-                &path.join("height_to_first_emptyindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_first_multisigindex: IndexedVec::forced_import(
-                &path.join("height_to_first_multisigindex"),
+            height_to_first_inputindex: IndexedVec::forced_import(
+                &path.join("height_to_first_inputindex"),
                 Version::ZERO,
                 compressed,
             )?,
@@ -128,28 +97,18 @@ impl Vecs {
                 Version::ZERO,
                 compressed,
             )?,
-            height_to_first_pushonlyindex: IndexedVec::forced_import(
-                &path.join("height_to_first_pushonlyindex"),
+            height_to_first_outputindex: IndexedVec::forced_import(
+                &path.join("height_to_first_outputindex"),
                 Version::ZERO,
                 compressed,
             )?,
-            height_to_first_txindex: IndexedVec::forced_import(
-                &path.join("height_to_first_txindex"),
+            height_to_first_p2aindex: IndexedVec::forced_import(
+                &path.join("height_to_first_p2aindex"),
                 Version::ZERO,
                 compressed,
             )?,
-            height_to_first_txinindex: IndexedVec::forced_import(
-                &path.join("height_to_first_txinindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_first_txoutindex: IndexedVec::forced_import(
-                &path.join("height_to_first_txoutindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            height_to_first_unknownindex: IndexedVec::forced_import(
-                &path.join("height_to_first_unkownindex"),
+            height_to_first_p2msindex: IndexedVec::forced_import(
+                &path.join("height_to_first_p2msindex"),
                 Version::ZERO,
                 compressed,
             )?,
@@ -188,8 +147,13 @@ impl Vecs {
                 Version::ZERO,
                 compressed,
             )?,
-            height_to_total_size: IndexedVec::forced_import(
-                &path.join("height_to_total_size"),
+            height_to_first_txindex: IndexedVec::forced_import(
+                &path.join("height_to_first_txindex"),
+                Version::ZERO,
+                compressed,
+            )?,
+            height_to_first_unknownoutputindex: IndexedVec::forced_import(
+                &path.join("height_to_first_unknownoutputindex"),
                 Version::ZERO,
                 compressed,
             )?,
@@ -198,68 +162,83 @@ impl Vecs {
                 Version::ZERO,
                 compressed,
             )?,
+            height_to_total_size: IndexedVec::forced_import(
+                &path.join("height_to_total_size"),
+                Version::ZERO,
+                compressed,
+            )?,
             height_to_weight: IndexedVec::forced_import(
                 &path.join("height_to_weight"),
                 Version::ZERO,
                 compressed,
             )?,
-            p2pk33index_to_p2pk33addressbytes: IndexedVec::forced_import(
-                &path.join("p2pk33index_to_p2pk33addressbytes"),
-                Version::ZERO,
-                Compressed::NO,
-            )?,
-            p2pk65index_to_p2pk65addressbytes: IndexedVec::forced_import(
-                &path.join("p2pk65index_to_p2pk65addressbytes"),
-                Version::ZERO,
-                Compressed::NO,
-            )?,
-            p2pkhindex_to_p2pkhaddressbytes: IndexedVec::forced_import(
-                &path.join("p2pkhindex_to_p2pkhaddressbytes"),
-                Version::ZERO,
-                Compressed::NO,
-            )?,
-            p2shindex_to_p2shaddressbytes: IndexedVec::forced_import(
-                &path.join("p2shindex_to_p2shaddressbytes"),
-                Version::ZERO,
-                Compressed::NO,
-            )?,
-            p2trindex_to_p2traddressbytes: IndexedVec::forced_import(
-                &path.join("p2trindex_to_p2traddressbytes"),
-                Version::ZERO,
-                Compressed::NO,
-            )?,
-            p2wpkhindex_to_p2wpkhaddressbytes: IndexedVec::forced_import(
-                &path.join("p2wpkhindex_to_p2wpkhaddressbytes"),
-                Version::ZERO,
-                Compressed::NO,
-            )?,
-            p2wshindex_to_p2wshaddressbytes: IndexedVec::forced_import(
-                &path.join("p2wshindex_to_p2wshaddressbytes"),
-                Version::ZERO,
-                Compressed::NO,
-            )?,
-            txindex_to_first_txinindex: IndexedVec::forced_import(
-                &path.join("txindex_to_first_txinindex"),
+            inputindex_to_outputindex: IndexedVec::forced_import(
+                &path.join("inputindex_to_outputindex"),
                 Version::ZERO,
                 compressed,
             )?,
-            txindex_to_first_txoutindex: IndexedVec::forced_import(
-                &path.join("txindex_to_first_txoutindex"),
+            opreturnindex_to_txindex: IndexedVec::forced_import(
+                &path.join("opreturnindex_to_txindex"),
+                Version::ZERO,
+                compressed,
+            )?,
+            outputindex_to_outputtype: IndexedVec::forced_import(
+                &path.join("outputindex_to_outputtype"),
+                Version::ZERO,
+                compressed,
+            )?,
+            outputindex_to_outputtypeindex: IndexedVec::forced_import(
+                &path.join("outputindex_to_outputtypeindex"),
+                Version::ZERO,
+                compressed,
+            )?,
+            outputindex_to_value: IndexedVec::forced_import(
+                &path.join("outputindex_to_value"),
+                Version::ZERO,
+                compressed,
+            )?,
+            p2aindex_to_p2abytes: IndexedVec::forced_import(
+                &path.join("p2aindex_to_p2abytes"),
                 Version::ZERO,
                 Compressed::NO,
             )?,
-            txindex_to_height: IndexedVec::forced_import(
-                &path.join("txindex_to_height"),
+            p2msindex_to_txindex: IndexedVec::forced_import(
+                &path.join("p2msindex_to_txindex"),
                 Version::ZERO,
                 compressed,
             )?,
-            txindex_to_locktime: IndexedVec::forced_import(
-                &path.join("txindex_to_locktime"),
+            p2pk33index_to_p2pk33bytes: IndexedVec::forced_import(
+                &path.join("p2pk33index_to_p2pk33bytes"),
                 Version::ZERO,
-                compressed,
+                Compressed::NO,
             )?,
-            txindex_to_txid: IndexedVec::forced_import(
-                &path.join("txindex_to_txid"),
+            p2pk65index_to_p2pk65bytes: IndexedVec::forced_import(
+                &path.join("p2pk65index_to_p2pk65bytes"),
+                Version::ZERO,
+                Compressed::NO,
+            )?,
+            p2pkhindex_to_p2pkhbytes: IndexedVec::forced_import(
+                &path.join("p2pkhindex_to_p2pkhbytes"),
+                Version::ZERO,
+                Compressed::NO,
+            )?,
+            p2shindex_to_p2shbytes: IndexedVec::forced_import(
+                &path.join("p2shindex_to_p2shbytes"),
+                Version::ZERO,
+                Compressed::NO,
+            )?,
+            p2trindex_to_p2trbytes: IndexedVec::forced_import(
+                &path.join("p2trindex_to_p2trbytes"),
+                Version::ZERO,
+                Compressed::NO,
+            )?,
+            p2wpkhindex_to_p2wpkhbytes: IndexedVec::forced_import(
+                &path.join("p2wpkhindex_to_p2wpkhbytes"),
+                Version::ZERO,
+                Compressed::NO,
+            )?,
+            p2wshindex_to_p2wshbytes: IndexedVec::forced_import(
+                &path.join("p2wshindex_to_p2wshbytes"),
                 Version::ZERO,
                 Compressed::NO,
             )?,
@@ -268,103 +247,43 @@ impl Vecs {
                 Version::ZERO,
                 compressed,
             )?,
-            txindex_to_total_size: IndexedVec::forced_import(
-                &path.join("txindex_to_total_size"),
+            txindex_to_first_inputindex: IndexedVec::forced_import(
+                &path.join("txindex_to_first_inputindex"),
                 Version::ZERO,
                 compressed,
             )?,
+            txindex_to_first_outputindex: IndexedVec::forced_import(
+                &path.join("txindex_to_first_outputindex"),
+                Version::ZERO,
+                Compressed::NO,
+            )?,
             txindex_to_is_explicitly_rbf: IndexedVec::forced_import(
                 &path.join("txindex_to_is_explicitly_rbf"),
                 Version::ZERO,
                 compressed,
             )?,
+            txindex_to_rawlocktime: IndexedVec::forced_import(
+                &path.join("txindex_to_rawlocktime"),
+                Version::ZERO,
+                compressed,
+            )?,
+            txindex_to_total_size: IndexedVec::forced_import(
+                &path.join("txindex_to_total_size"),
+                Version::ZERO,
+                compressed,
+            )?,
+            txindex_to_txid: IndexedVec::forced_import(
+                &path.join("txindex_to_txid"),
+                Version::ZERO,
+                Compressed::NO,
+            )?,
             txindex_to_txversion: IndexedVec::forced_import(
                 &path.join("txindex_to_txversion"),
                 Version::ZERO,
                 compressed,
             )?,
-            txinindex_to_txoutindex: IndexedVec::forced_import(
-                &path.join("txinindex_to_txoutindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            txoutindex_to_addressindex: IndexedVec::forced_import(
-                &path.join("txoutindex_to_addressindex"),
-                Version::ZERO,
-                compressed,
-            )?,
-            txoutindex_to_value: IndexedVec::forced_import(
-                &path.join("txoutindex_to_value"),
-                Version::ZERO,
-                compressed,
-            )?,
-            emptyindex_to_height: IndexedVec::forced_import(
-                &path.join("emptyindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            multisigindex_to_height: IndexedVec::forced_import(
-                &path.join("multisigindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            opreturnindex_to_height: IndexedVec::forced_import(
-                &path.join("opreturnindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            pushonlyindex_to_height: IndexedVec::forced_import(
-                &path.join("pushonlyindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            txinindex_to_height: IndexedVec::forced_import(
-                &path.join("txinindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            txoutindex_to_height: IndexedVec::forced_import(
-                &path.join("txoutindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            unknownindex_to_height: IndexedVec::forced_import(
-                &path.join("unknownindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2pk33index_to_height: IndexedVec::forced_import(
-                &path.join("p2pk33index_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2pk65index_to_height: IndexedVec::forced_import(
-                &path.join("p2pk65index_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2pkhindex_to_height: IndexedVec::forced_import(
-                &path.join("p2pkhindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2shindex_to_height: IndexedVec::forced_import(
-                &path.join("p2shindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2trindex_to_height: IndexedVec::forced_import(
-                &path.join("p2trindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2wpkhindex_to_height: IndexedVec::forced_import(
-                &path.join("p2wpkhindex_to_height"),
-                Version::ZERO,
-                compressed,
-            )?,
-            p2wshindex_to_height: IndexedVec::forced_import(
-                &path.join("p2wshindex_to_height"),
+            unknownoutputindex_to_txindex: IndexedVec::forced_import(
+                &path.join("unknownoutputindex_to_txindex"),
                 Version::ZERO,
                 compressed,
             )?,
@@ -375,8 +294,13 @@ impl Vecs {
         let saved_height = starting_indexes.height.decremented().unwrap_or_default();
 
         let &Indexes {
-            addressindex,
+            emptyoutputindex,
             height,
+            inputindex,
+            opreturnindex,
+            outputindex,
+            p2aindex,
+            p2msindex,
             p2pk33index,
             p2pk65index,
             p2pkhindex,
@@ -385,23 +309,27 @@ impl Vecs {
             p2wpkhindex,
             p2wshindex,
             txindex,
-            txinindex,
-            txoutindex,
-            unknownindex,
-            pushonlyindex,
-            opreturnindex,
-            multisigindex,
-            emptyindex,
+            unknownoutputindex,
         } = starting_indexes;
 
-        self.height_to_first_addressindex
+        self.emptyoutputindex_to_txindex
+            .truncate_if_needed(emptyoutputindex, saved_height)?;
+        self.height_to_blockhash
             .truncate_if_needed(height, saved_height)?;
-        self.height_to_first_emptyindex
+        self.height_to_difficulty
             .truncate_if_needed(height, saved_height)?;
-        self.height_to_first_multisigindex
+        self.height_to_first_emptyoutputindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_inputindex
             .truncate_if_needed(height, saved_height)?;
         self.height_to_first_opreturnindex
             .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_outputindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2aindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2msindex
+            .truncate_if_needed(height, saved_height)?;
         self.height_to_first_p2pk33index
             .truncate_if_needed(height, saved_height)?;
         self.height_to_first_p2pk65index
@@ -416,276 +344,173 @@ impl Vecs {
             .truncate_if_needed(height, saved_height)?;
         self.height_to_first_p2wshindex
             .truncate_if_needed(height, saved_height)?;
-        self.height_to_first_pushonlyindex
-            .truncate_if_needed(height, saved_height)?;
         self.height_to_first_txindex
             .truncate_if_needed(height, saved_height)?;
-        self.height_to_first_txinindex
-            .truncate_if_needed(height, saved_height)?;
-        self.height_to_first_txoutindex
-            .truncate_if_needed(height, saved_height)?;
-        self.height_to_first_unknownindex
-            .truncate_if_needed(height, saved_height)?;
-
-        self.height_to_blockhash
-            .truncate_if_needed(height, saved_height)?;
-        self.height_to_difficulty
-            .truncate_if_needed(height, saved_height)?;
-        self.height_to_total_size
+        self.height_to_first_unknownoutputindex
             .truncate_if_needed(height, saved_height)?;
         self.height_to_timestamp
             .truncate_if_needed(height, saved_height)?;
+        self.height_to_total_size
+            .truncate_if_needed(height, saved_height)?;
         self.height_to_weight
             .truncate_if_needed(height, saved_height)?;
-
-        self.addressindex_to_addresstype
-            .truncate_if_needed(addressindex, saved_height)?;
-        self.addressindex_to_addresstypeindex
-            .truncate_if_needed(addressindex, saved_height)?;
-        self.addressindex_to_height
-            .truncate_if_needed(addressindex, saved_height)?;
-
-        self.p2pk33index_to_p2pk33addressbytes
+        self.inputindex_to_outputindex
+            .truncate_if_needed(inputindex, saved_height)?;
+        self.opreturnindex_to_txindex
+            .truncate_if_needed(opreturnindex, saved_height)?;
+        self.outputindex_to_outputtype
+            .truncate_if_needed(outputindex, saved_height)?;
+        self.outputindex_to_outputtypeindex
+            .truncate_if_needed(outputindex, saved_height)?;
+        self.outputindex_to_value
+            .truncate_if_needed(outputindex, saved_height)?;
+        self.p2aindex_to_p2abytes
+            .truncate_if_needed(p2aindex, saved_height)?;
+        self.p2msindex_to_txindex
+            .truncate_if_needed(p2msindex, saved_height)?;
+        self.p2pk33index_to_p2pk33bytes
             .truncate_if_needed(p2pk33index, saved_height)?;
-        self.p2pk65index_to_p2pk65addressbytes
+        self.p2pk65index_to_p2pk65bytes
             .truncate_if_needed(p2pk65index, saved_height)?;
-        self.p2pkhindex_to_p2pkhaddressbytes
+        self.p2pkhindex_to_p2pkhbytes
             .truncate_if_needed(p2pkhindex, saved_height)?;
-        self.p2shindex_to_p2shaddressbytes
+        self.p2shindex_to_p2shbytes
             .truncate_if_needed(p2shindex, saved_height)?;
-        self.p2trindex_to_p2traddressbytes
+        self.p2trindex_to_p2trbytes
             .truncate_if_needed(p2trindex, saved_height)?;
-        self.p2wpkhindex_to_p2wpkhaddressbytes
+        self.p2wpkhindex_to_p2wpkhbytes
             .truncate_if_needed(p2wpkhindex, saved_height)?;
-        self.p2wshindex_to_p2wshaddressbytes
+        self.p2wshindex_to_p2wshbytes
             .truncate_if_needed(p2wshindex, saved_height)?;
-
-        self.txindex_to_first_txinindex
+        self.txindex_to_base_size
             .truncate_if_needed(txindex, saved_height)?;
-        self.txindex_to_first_txoutindex
+        self.txindex_to_first_inputindex
             .truncate_if_needed(txindex, saved_height)?;
-        self.txindex_to_height
+        self.txindex_to_first_outputindex
             .truncate_if_needed(txindex, saved_height)?;
-        self.txindex_to_locktime
+        self.txindex_to_is_explicitly_rbf
+            .truncate_if_needed(txindex, saved_height)?;
+        self.txindex_to_rawlocktime
+            .truncate_if_needed(txindex, saved_height)?;
+        self.txindex_to_total_size
             .truncate_if_needed(txindex, saved_height)?;
         self.txindex_to_txid
             .truncate_if_needed(txindex, saved_height)?;
         self.txindex_to_txversion
             .truncate_if_needed(txindex, saved_height)?;
-        self.txindex_to_base_size
-            .truncate_if_needed(txindex, saved_height)?;
-        self.txindex_to_total_size
-            .truncate_if_needed(txindex, saved_height)?;
-        self.txindex_to_is_explicitly_rbf
-            .truncate_if_needed(txindex, saved_height)?;
-
-        self.txinindex_to_txoutindex
-            .truncate_if_needed(txinindex, saved_height)?;
-
-        self.txoutindex_to_addressindex
-            .truncate_if_needed(txoutindex, saved_height)?;
-        self.txoutindex_to_value
-            .truncate_if_needed(txoutindex, saved_height)?;
-
-        self.emptyindex_to_height
-            .truncate_if_needed(emptyindex, saved_height)?;
-        self.multisigindex_to_height
-            .truncate_if_needed(multisigindex, saved_height)?;
-        self.opreturnindex_to_height
-            .truncate_if_needed(opreturnindex, saved_height)?;
-        self.pushonlyindex_to_height
-            .truncate_if_needed(pushonlyindex, saved_height)?;
-        self.txinindex_to_height
-            .truncate_if_needed(txinindex, saved_height)?;
-        self.txoutindex_to_height
-            .truncate_if_needed(txoutindex, saved_height)?;
-        self.unknownindex_to_height
-            .truncate_if_needed(unknownindex, saved_height)?;
-        self.p2pk33index_to_height
-            .truncate_if_needed(p2pk33index, saved_height)?;
-        self.p2pk65index_to_height
-            .truncate_if_needed(p2pk65index, saved_height)?;
-        self.p2pkhindex_to_height
-            .truncate_if_needed(p2pkhindex, saved_height)?;
-        self.p2shindex_to_height
-            .truncate_if_needed(p2shindex, saved_height)?;
-        self.p2trindex_to_height
-            .truncate_if_needed(p2trindex, saved_height)?;
-        self.p2wpkhindex_to_height
-            .truncate_if_needed(p2wpkhindex, saved_height)?;
-        self.p2wshindex_to_height
-            .truncate_if_needed(p2wshindex, saved_height)?;
+        self.unknownoutputindex_to_txindex
+            .truncate_if_needed(unknownoutputindex, saved_height)?;
 
         Ok(())
     }
 
-    pub fn get_addressbytes(
-        &self,
-        addresstype: Addresstype,
-        addresstypeindex: Addresstypeindex,
-    ) -> brk_vec::Result<Option<Addressbytes>> {
-        Ok(match addresstype {
-            Addresstype::P2PK65 => self
-                .p2pk65index_to_p2pk65addressbytes
-                .get(addresstypeindex.into())?
-                // .map(|v| Addressbytes::from(v.clone())),
-                .map(|v| Addressbytes::from(v.into_inner())),
-            Addresstype::P2PK33 => self
-                .p2pk33index_to_p2pk33addressbytes
-                .get(addresstypeindex.into())?
-                // .map(|v| Addressbytes::from(v.clone())),
-                .map(|v| Addressbytes::from(v.into_inner())),
-            Addresstype::P2PKH => self
-                .p2pkhindex_to_p2pkhaddressbytes
-                .get(addresstypeindex.into())?
-                // .map(|v| Addressbytes::from(v.clone())),
-                .map(|v| Addressbytes::from(v.into_inner())),
-            Addresstype::P2SH => self
-                .p2shindex_to_p2shaddressbytes
-                .get(addresstypeindex.into())?
-                // .map(|v| Addressbytes::from(v.clone())),
-                .map(|v| Addressbytes::from(v.into_inner())),
-            Addresstype::P2WPKH => self
-                .p2wpkhindex_to_p2wpkhaddressbytes
-                .get(addresstypeindex.into())?
-                // .map(|v| Addressbytes::from(v.clone())),
-                .map(|v| Addressbytes::from(v.into_inner())),
-            Addresstype::P2WSH => self
-                .p2wshindex_to_p2wshaddressbytes
-                .get(addresstypeindex.into())?
-                // .map(|v| Addressbytes::from(v.clone())),
-                .map(|v| Addressbytes::from(v.into_inner())),
-            Addresstype::P2TR => self
-                .p2trindex_to_p2traddressbytes
-                .get(addresstypeindex.into())?
-                // .map(|v| Addressbytes::from(v.clone())),
-                .map(|v| Addressbytes::from(v.into_inner())),
-            _ => unreachable!(),
-        })
-    }
-
-    pub fn push_addressbytes_if_needed(
+    pub fn push_bytes_if_needed(
         &mut self,
-        index: Addresstypeindex,
-        addressbytes: Addressbytes,
+        index: OutputTypeIndex,
+        bytes: AddressBytes,
     ) -> brk_vec::Result<()> {
-        match addressbytes {
-            Addressbytes::P2PK65(bytes) => self
-                .p2pk65index_to_p2pk65addressbytes
+        match bytes {
+            AddressBytes::P2PK65(bytes) => self
+                .p2pk65index_to_p2pk65bytes
                 .push_if_needed(index.into(), bytes),
-            Addressbytes::P2PK33(bytes) => self
-                .p2pk33index_to_p2pk33addressbytes
+            AddressBytes::P2PK33(bytes) => self
+                .p2pk33index_to_p2pk33bytes
                 .push_if_needed(index.into(), bytes),
-            Addressbytes::P2PKH(bytes) => self
-                .p2pkhindex_to_p2pkhaddressbytes
+            AddressBytes::P2PKH(bytes) => self
+                .p2pkhindex_to_p2pkhbytes
                 .push_if_needed(index.into(), bytes),
-            Addressbytes::P2SH(bytes) => self
-                .p2shindex_to_p2shaddressbytes
+            AddressBytes::P2SH(bytes) => self
+                .p2shindex_to_p2shbytes
                 .push_if_needed(index.into(), bytes),
-            Addressbytes::P2WPKH(bytes) => self
-                .p2wpkhindex_to_p2wpkhaddressbytes
+            AddressBytes::P2WPKH(bytes) => self
+                .p2wpkhindex_to_p2wpkhbytes
                 .push_if_needed(index.into(), bytes),
-            Addressbytes::P2WSH(bytes) => self
-                .p2wshindex_to_p2wshaddressbytes
+            AddressBytes::P2WSH(bytes) => self
+                .p2wshindex_to_p2wshbytes
                 .push_if_needed(index.into(), bytes),
-            Addressbytes::P2TR(bytes) => self
-                .p2trindex_to_p2traddressbytes
+            AddressBytes::P2TR(bytes) => self
+                .p2trindex_to_p2trbytes
+                .push_if_needed(index.into(), bytes),
+            AddressBytes::P2A(bytes) => self
+                .p2aindex_to_p2abytes
                 .push_if_needed(index.into(), bytes),
         }
     }
 
     pub fn flush(&mut self, height: Height) -> Result<()> {
-        self.as_mut_any_vecs()
+        self.mut_vecs()
             .into_par_iter()
             .try_for_each(|vec| vec.flush(height))
     }
 
     pub fn starting_height(&mut self) -> Height {
-        self.as_mut_any_vecs()
+        self.mut_vecs()
             .into_iter()
             .map(|vec| vec.height().map(Height::incremented).unwrap_or_default())
             .min()
             .unwrap()
     }
 
-    pub fn as_any_vecs(&self) -> Vec<&dyn AnyStoredVec> {
+    pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
         vec![
-            self.addressindex_to_addresstype.any_vec(),
-            self.addressindex_to_addresstypeindex.any_vec(),
-            self.addressindex_to_height.any_vec(),
-            self.height_to_blockhash.any_vec(),
-            self.height_to_difficulty.any_vec(),
-            self.height_to_first_addressindex.any_vec(),
-            self.height_to_first_emptyindex.any_vec(),
-            self.height_to_first_multisigindex.any_vec(),
-            self.height_to_first_opreturnindex.any_vec(),
-            self.height_to_first_pushonlyindex.any_vec(),
-            self.height_to_first_txindex.any_vec(),
-            self.height_to_first_txinindex.any_vec(),
-            self.height_to_first_txoutindex.any_vec(),
-            self.height_to_first_unknownindex.any_vec(),
-            self.height_to_first_p2pk33index.any_vec(),
-            self.height_to_first_p2pk65index.any_vec(),
-            self.height_to_first_p2pkhindex.any_vec(),
-            self.height_to_first_p2shindex.any_vec(),
-            self.height_to_first_p2trindex.any_vec(),
-            self.height_to_first_p2wpkhindex.any_vec(),
-            self.height_to_first_p2wshindex.any_vec(),
-            self.height_to_total_size.any_vec(),
-            self.height_to_timestamp.any_vec(),
-            self.height_to_weight.any_vec(),
-            self.p2pk33index_to_p2pk33addressbytes.any_vec(),
-            self.p2pk65index_to_p2pk65addressbytes.any_vec(),
-            self.p2pkhindex_to_p2pkhaddressbytes.any_vec(),
-            self.p2shindex_to_p2shaddressbytes.any_vec(),
-            self.p2trindex_to_p2traddressbytes.any_vec(),
-            self.p2wpkhindex_to_p2wpkhaddressbytes.any_vec(),
-            self.p2wshindex_to_p2wshaddressbytes.any_vec(),
-            self.txindex_to_first_txinindex.any_vec(),
-            self.txindex_to_first_txoutindex.any_vec(),
-            self.txindex_to_height.any_vec(),
-            self.txindex_to_locktime.any_vec(),
-            self.txindex_to_txid.any_vec(),
-            self.txindex_to_base_size.any_vec(),
-            self.txindex_to_total_size.any_vec(),
-            self.txindex_to_is_explicitly_rbf.any_vec(),
-            self.txindex_to_txversion.any_vec(),
-            self.txinindex_to_txoutindex.any_vec(),
-            self.txoutindex_to_addressindex.any_vec(),
-            self.txoutindex_to_value.any_vec(),
-            self.emptyindex_to_height.any_vec(),
-            self.multisigindex_to_height.any_vec(),
-            self.opreturnindex_to_height.any_vec(),
-            self.pushonlyindex_to_height.any_vec(),
-            self.txinindex_to_height.any_vec(),
-            self.txoutindex_to_height.any_vec(),
-            self.unknownindex_to_height.any_vec(),
-            self.p2pk33index_to_height.any_vec(),
-            self.p2pk65index_to_height.any_vec(),
-            self.p2pkhindex_to_height.any_vec(),
-            self.p2shindex_to_height.any_vec(),
-            self.p2trindex_to_height.any_vec(),
-            self.p2wpkhindex_to_height.any_vec(),
-            self.p2wshindex_to_height.any_vec(),
+            &self.emptyoutputindex_to_txindex,
+            &self.height_to_blockhash,
+            &self.height_to_difficulty,
+            &self.height_to_first_emptyoutputindex,
+            &self.height_to_first_inputindex,
+            &self.height_to_first_opreturnindex,
+            &self.height_to_first_outputindex,
+            &self.height_to_first_p2aindex,
+            &self.height_to_first_p2msindex,
+            &self.height_to_first_p2pk33index,
+            &self.height_to_first_p2pk65index,
+            &self.height_to_first_p2pkhindex,
+            &self.height_to_first_p2shindex,
+            &self.height_to_first_p2trindex,
+            &self.height_to_first_p2wpkhindex,
+            &self.height_to_first_p2wshindex,
+            &self.height_to_first_txindex,
+            &self.height_to_first_unknownoutputindex,
+            &self.height_to_timestamp,
+            &self.height_to_total_size,
+            &self.height_to_weight,
+            &self.inputindex_to_outputindex,
+            &self.opreturnindex_to_txindex,
+            &self.outputindex_to_outputtype,
+            &self.outputindex_to_outputtypeindex,
+            &self.outputindex_to_value,
+            &self.p2aindex_to_p2abytes,
+            &self.p2msindex_to_txindex,
+            &self.p2pk33index_to_p2pk33bytes,
+            &self.p2pk65index_to_p2pk65bytes,
+            &self.p2pkhindex_to_p2pkhbytes,
+            &self.p2shindex_to_p2shbytes,
+            &self.p2trindex_to_p2trbytes,
+            &self.p2wpkhindex_to_p2wpkhbytes,
+            &self.p2wshindex_to_p2wshbytes,
+            &self.txindex_to_base_size,
+            &self.txindex_to_first_inputindex,
+            &self.txindex_to_first_outputindex,
+            &self.txindex_to_is_explicitly_rbf,
+            &self.txindex_to_rawlocktime,
+            &self.txindex_to_total_size,
+            &self.txindex_to_txid,
+            &self.txindex_to_txversion,
+            &self.unknownoutputindex_to_txindex,
         ]
     }
 
-    fn as_mut_any_vecs(&mut self) -> Vec<&mut dyn AnyIndexedVec> {
+    fn mut_vecs(&mut self) -> Vec<&mut dyn AnyIndexedVec> {
         vec![
-            &mut self.addressindex_to_addresstype,
-            &mut self.addressindex_to_addresstypeindex,
-            &mut self.addressindex_to_height,
+            &mut self.emptyoutputindex_to_txindex,
             &mut self.height_to_blockhash,
             &mut self.height_to_difficulty,
-            &mut self.height_to_first_addressindex,
-            &mut self.height_to_first_emptyindex,
-            &mut self.height_to_first_multisigindex,
+            &mut self.height_to_first_emptyoutputindex,
+            &mut self.height_to_first_inputindex,
             &mut self.height_to_first_opreturnindex,
-            &mut self.height_to_first_pushonlyindex,
-            &mut self.height_to_first_txindex,
-            &mut self.height_to_first_txinindex,
-            &mut self.height_to_first_txoutindex,
-            &mut self.height_to_first_unknownindex,
+            &mut self.height_to_first_outputindex,
+            &mut self.height_to_first_p2aindex,
+            &mut self.height_to_first_p2msindex,
             &mut self.height_to_first_p2pk33index,
             &mut self.height_to_first_p2pk65index,
             &mut self.height_to_first_p2pkhindex,
@@ -693,42 +518,34 @@ impl Vecs {
             &mut self.height_to_first_p2trindex,
             &mut self.height_to_first_p2wpkhindex,
             &mut self.height_to_first_p2wshindex,
-            &mut self.height_to_total_size,
+            &mut self.height_to_first_txindex,
+            &mut self.height_to_first_unknownoutputindex,
             &mut self.height_to_timestamp,
+            &mut self.height_to_total_size,
             &mut self.height_to_weight,
-            &mut self.p2pk33index_to_p2pk33addressbytes,
-            &mut self.p2pk65index_to_p2pk65addressbytes,
-            &mut self.p2pkhindex_to_p2pkhaddressbytes,
-            &mut self.p2shindex_to_p2shaddressbytes,
-            &mut self.p2trindex_to_p2traddressbytes,
-            &mut self.p2wpkhindex_to_p2wpkhaddressbytes,
-            &mut self.p2wshindex_to_p2wshaddressbytes,
-            &mut self.txindex_to_first_txinindex,
-            &mut self.txindex_to_first_txoutindex,
-            &mut self.txindex_to_height,
-            &mut self.txindex_to_locktime,
-            &mut self.txindex_to_txid,
+            &mut self.inputindex_to_outputindex,
+            &mut self.opreturnindex_to_txindex,
+            &mut self.outputindex_to_outputtype,
+            &mut self.outputindex_to_outputtypeindex,
+            &mut self.outputindex_to_value,
+            &mut self.p2aindex_to_p2abytes,
+            &mut self.p2msindex_to_txindex,
+            &mut self.p2pk33index_to_p2pk33bytes,
+            &mut self.p2pk65index_to_p2pk65bytes,
+            &mut self.p2pkhindex_to_p2pkhbytes,
+            &mut self.p2shindex_to_p2shbytes,
+            &mut self.p2trindex_to_p2trbytes,
+            &mut self.p2wpkhindex_to_p2wpkhbytes,
+            &mut self.p2wshindex_to_p2wshbytes,
             &mut self.txindex_to_base_size,
-            &mut self.txindex_to_total_size,
+            &mut self.txindex_to_first_inputindex,
+            &mut self.txindex_to_first_outputindex,
             &mut self.txindex_to_is_explicitly_rbf,
+            &mut self.txindex_to_rawlocktime,
+            &mut self.txindex_to_total_size,
+            &mut self.txindex_to_txid,
             &mut self.txindex_to_txversion,
-            &mut self.txinindex_to_txoutindex,
-            &mut self.txoutindex_to_addressindex,
-            &mut self.txoutindex_to_value,
-            &mut self.emptyindex_to_height,
-            &mut self.multisigindex_to_height,
-            &mut self.opreturnindex_to_height,
-            &mut self.pushonlyindex_to_height,
-            &mut self.txinindex_to_height,
-            &mut self.txoutindex_to_height,
-            &mut self.unknownindex_to_height,
-            &mut self.p2pk33index_to_height,
-            &mut self.p2pk65index_to_height,
-            &mut self.p2pkhindex_to_height,
-            &mut self.p2shindex_to_height,
-            &mut self.p2trindex_to_height,
-            &mut self.p2wpkhindex_to_height,
-            &mut self.p2wshindex_to_height,
+            &mut self.unknownoutputindex_to_txindex,
         ]
     }
 }

crates/brk_logger/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>

crates/brk_parser/README.md

@@ -29,7 +29,7 @@
   <a href="https://bsky.app/profile/bitcoinresearchkit.org">
     <img src="https://img.shields.io/badge/bluesky-blue?link=https%3A%2F%2Fbsky.app%2Fprofile%2Fbitcoinresearchkit.org" alt="Bluesky" />
   </a>
-  <a href="https://x.com/0xbrk">
+  <a href="https://x.com/brkdotorg">
     <img src="https://img.shields.io/badge/x.com-black" alt="X" />
   </a>
 </p>
@@ -41,23 +41,29 @@ The element returned by the iterator is a tuple which includes the:
 - Block: `Block` (from `bitcoin-rust`)
 - Block's Hash: `BlockHash` (also from `bitcoin-rust`)
 
-## Example
-
-`src/main.rs`
+Tested with Bitcoin Core `v25.0..=v28.1`
 
 ## Requirements
 
-Even though it reads *blkXXXXX.dat* files, it **needs** `bitcoind` to run with the RPC server to filter out block forks.
+Even though it reads *blkXXXXX.dat* files, it **needs** `bitcoind` (with no particular parameters) to run with the RPC server to filter out forks.
 
 Peak memory should be around 500MB.
 
-## Comparaison
+XOR-ed blocks are supported.
 
-|  | [brk_parser](https://crates.io/crates/brk_parser) | [bitcoin-explorer (deprecated)](https://crates.io/crates/bitcoin-explorer) | [blocks_iterator](https://crates.io/crates/blocks_iterator) |
+## Disclaimer
+
+A state of the local chain is saved in `{bitcoindir}/blocks/blk_index_to_blk_recap.json` to allow for faster starts (see benchmark below) but doesn't yet support locking. Thus, it is highly recommended to run one instance of `brk_parser` at a time.
+
+## Benchmark
+
+|  | [brk_parser](https://crates.io/crates/brk_parser) | [bitcoin-explorer (deprecated)](https://crates.io/crates/bitcoin-explorer) | [blocks_iterator](https://crates.io/crates/blocks_iterator)* |
 | --- | --- | --- | --- |
 | Runs **with** `bitcoind` | Yes ✅ | No ❌ | Yes ✅ |
 | Runs **without** `bitcoind` | No ❌ | Yes ✅ | Yes ✅ |
 | `0..=855_000` | 4mn 10s | 4mn 45s | > 2h |
 | `800_000..=855_000` | 0mn 52s (4mn 10s if first run) | 0mn 55s | > 2h |
 
+\* `blocks_iterator` is with the default config (and thus with `skip_prevout = false` which does a lot more than just iterate over blocks) so it isn't an apples to apples comparaison and the numbers are misleading. You should expect much closer times. Will update the benchmark with `skip_prevout = true` as soon as possible.
+
 *Benchmarked on a Macbook Pro M3 Pro*

crates/brk_parser/examples/p2a.rs

@@ -0,0 +1,69 @@
+use bitcoincore_rpc::{Auth, Client};
+use brk_core::{Height, OutputType, default_bitcoin_path};
+use brk_parser::Parser;
+
+fn main() {
+    let i = std::time::Instant::now();
+
+    let bitcoin_dir = default_bitcoin_path();
+
+    let rpc = Box::leak(Box::new(
+        Client::new(
+            "http://localhost:8332",
+            Auth::CookieFile(bitcoin_dir.join(".cookie")),
+        )
+        .unwrap(),
+    ));
+
+    // let start = None;
+    // let end = None;
+
+    let parser = Parser::new(bitcoin_dir.join("blocks"), rpc);
+
+    // parser
+    //     .parse(start, end)
+    //     .iter()
+    //     .for_each(|(height, _block, hash)| {
+    //         println!("{height}: {hash}");
+    //     });
+
+    // println!(
+    //     "{}",
+    //     parser
+    //         .get(Height::new(0))
+    //         .txdata
+    //         .first()
+    //         .unwrap()
+    //         .output
+    //         .first()
+    //         .unwrap()
+    //         .script_pubkey
+    // );
+
+    let block_850_000 = parser.get(Height::new(850_000));
+
+    let tx = block_850_000.txdata.iter().find(|tx| {
+        tx.compute_txid().to_string()
+            == "b10c0000004da5a9d1d9b4ae32e09f0b3e62d21a5cce5428d4ad714fb444eb5d"
+    });
+
+    let output = tx.unwrap().tx_out(7).unwrap();
+
+    dbg!(OutputType::from(&output.script_pubkey));
+
+    dbg!(output);
+
+    // println!(
+    //     "{}",
+
+    //         .txdata
+    //         .first()
+    //         .unwrap()
+    //         .output
+    //         .first()
+    //         .unwrap()
+    //         .value
+    // );
+
+    dbg!(i.elapsed());
+}

crates/brk_parser/src/blk_index_to_blk_recap.rs

@@ -14,7 +14,11 @@ pub struct BlkIndexToBlkRecap {
 }
 
 impl BlkIndexToBlkRecap {
-    pub fn import(bitcoin_dir: &Path, blk_index_to_blk_path: &BlkIndexToBlkPath, start: Option<Height>) -> (Self, u16) {
+    pub fn import(
+        bitcoin_dir: &Path,
+        blk_index_to_blk_path: &BlkIndexToBlkPath,
+        start: Option<Height>,
+    ) -> (Self, u16) {
         let path = bitcoin_dir.join("blk_index_to_blk_recap.json");
 
         let tree = {
@@ -40,17 +44,19 @@ impl BlkIndexToBlkRecap {
 
         let mut unprocessed_keys = self.tree.keys().copied().collect::<BTreeSet<_>>();
 
-        blk_index_to_blk_path.iter().for_each(|(blk_index, blk_path)| {
-            unprocessed_keys.remove(blk_index);
-            if let Some(blk_recap) = self.tree.get(blk_index) {
-                if blk_recap.has_different_modified_time(blk_path) {
-                    self.tree.remove(blk_index).unwrap();
-                    if min_removed_blk_index.is_none_or(|_blk_index| *blk_index < _blk_index) {
-                        min_removed_blk_index.replace(*blk_index);
+        blk_index_to_blk_path
+            .iter()
+            .for_each(|(blk_index, blk_path)| {
+                unprocessed_keys.remove(blk_index);
+                if let Some(blk_recap) = self.tree.get(blk_index) {
+                    if blk_recap.has_different_modified_time(blk_path) {
+                        self.tree.remove(blk_index).unwrap();
+                        if min_removed_blk_index.is_none_or(|_blk_index| *blk_index < _blk_index) {
+                            min_removed_blk_index.replace(*blk_index);
+                        }
                     }
                 }
-            }
-        });
+            });
 
         unprocessed_keys.into_iter().for_each(|blk_index| {
             self.tree.remove(&blk_index).unwrap();
@@ -71,7 +77,11 @@ impl BlkIndexToBlkRecap {
 
         let mut start = None;
 
-        if let Some(found) = self.tree.iter().find(|(_, recap)| recap.max_height >= height) {
+        if let Some(found) = self
+            .tree
+            .iter()
+            .find(|(_, recap)| recap.max_height >= height)
+        {
             start = Some(*found.0);
         }
 

crates/brk_query/Cargo.toml

@@ -11,6 +11,7 @@ brk_computer = { workspace = true }
 brk_indexer = { workspace = true }
 brk_vec = { workspace = true }
 clap = { workspace = true }
+clap_derive = { workspace = true }
 color-eyre = { workspace = true }
 derive_deref = { workspace = true }
 serde = { workspace = true }