brk: first commit

crates/brk_indexer/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "brk_indexer"
+description = "A bitcoin-core indexer built on top of brk_parser"
+version = "0.1.0"
+edition = { workspace = true }
+license = { workspace = true }
+
+[dependencies]
+bitcoin = { workspace = true }
+brk_parser = { workspace = true }
+brk_printer = { workspace = true }
+color-eyre = { workspace = true }
+derive_deref = { workspace = true }
+fjall = { workspace = true }
+hodor = { workspace = true }
+jiff = { workspace = true }
+log = { workspace = true }
+rapidhash = "1.4.0"
+rayon = { workspace = true }
+rlimit = { version = "0.10.2" }
+serde = { workspace = true }
+serde_bytes = { workspace = true }
+storable_vec = { workspace = true }
+zerocopy = { workspace = true }

crates/brk_indexer/README.md

@@ -0,0 +1,29 @@
+# Indexer
+
+A [Bitcoin Core](https://bitcoincore.org/en/about/) node indexer which iterates over the chain (via `../iterator`) and creates a database of the vecs (`../storable_vec`) and key/value stores ([`fjall`](https://crates.io/crates/fjall)) that can be used in your Rust code.
+
+The crate only stores the bare minimum to be self sufficient and not have to use an RPC client (except for scripts which are not stored). If you need more data, checkout `../computer` which uses the outputs from the indexer to compute a whole range of datasets.
+
+Vecs are used sparingly instead of stores for multiple reasons:
+
+- Only stores the relevant data since the key is an index
+- Saved as uncompressed bytes and thus can be parsed manually (with any programming language) without relying on a server or library
+- Easy to work with and predictable
+
+## Usage
+
+Storage wise, the expected overhead should be around 30% of the chain itself.
+
+Peaks at 11-13 GB of RAM
+
+## Outputs
+
+Vecs: `src/storage/storable_vecs/mod.rs`
+
+Stores: `src/storage/fjalls/mod.rs`
+
+## Examples
+
+Rust: `src/main.rs`
+
+Python: `../python/parse.py`

crates/brk_indexer/src/lib.rs

@@ -0,0 +1,633 @@
+use std::{
+    collections::BTreeMap,
+    path::Path,
+    str::FromStr,
+    thread::{self, sleep},
+    time::Duration,
+};
+
+pub use brk_parser::*;
+
+use bitcoin::{Transaction, TxIn, TxOut};
+use color_eyre::eyre::{ContextCompat, eyre};
+use hodor::Exit;
+use log::info;
+use rayon::prelude::*;
+use storable_vec::CACHED_GETS;
+
+mod storage;
+mod structs;
+
+pub use storage::{AnyStorableVec, StorableVec, Store, StoreMeta};
+use storage::{Fjalls, StorableVecs};
+pub use structs::*;
+
+const SNAPSHOT_BLOCK_RANGE: usize = 1000;
+
+pub struct Indexer<const MODE: u8> {
+    pub vecs: StorableVecs<MODE>,
+    pub trees: Fjalls,
+}
+
+impl<const MODE: u8> Indexer<MODE> {
+    pub fn import(indexes_dir: &Path) -> color_eyre::Result<Self> {
+        // info!("Increasing limit of opened files to 210_000...");
+        rlimit::setrlimit(
+            rlimit::Resource::NOFILE,
+            210_000,
+            rlimit::getrlimit(rlimit::Resource::NOFILE).unwrap().1,
+        )?;
+
+        info!("Importing indexes...");
+        let vecs = StorableVecs::import(&indexes_dir.join("vecs"))?;
+        let trees = Fjalls::import(&indexes_dir.join("fjall"))?;
+
+        Ok(Self { vecs, trees })
+    }
+}
+
+impl Indexer<CACHED_GETS> {
+    pub fn index(&mut self, bitcoin_dir: &Path, rpc: &'static rpc::Client, exit: &Exit) -> color_eyre::Result<()> {
+        info!("Started indexing...");
+
+        let check_collisions = true;
+
+        let starting_indexes = Indexes::try_from((&mut self.vecs, &self.trees, rpc)).unwrap_or_else(|_| {
+            let indexes = Indexes::default();
+            indexes.push_if_needed(&mut self.vecs).unwrap();
+            indexes
+        });
+
+        exit.block();
+        self.trees.rollback(&self.vecs, &starting_indexes)?;
+        self.vecs.rollback(&starting_indexes)?;
+        exit.unblock();
+
+        let export =
+            |trees: &mut Fjalls, vecs: &mut StorableVecs<CACHED_GETS>, height: Height| -> color_eyre::Result<()> {
+                info!("Exporting...");
+                exit.block();
+                trees.commit(height)?;
+                vecs.flush(height)?;
+                exit.unblock();
+                Ok(())
+            };
+
+        let vecs = &mut self.vecs;
+        let trees = &mut self.trees;
+
+        let mut idxs = starting_indexes;
+
+        brk_parser::new(bitcoin_dir, Some(idxs.height), None, rpc)
+            .iter()
+            .try_for_each(|(height, block, blockhash)| -> color_eyre::Result<()> {
+                info!("Indexing block {height}...");
+
+                idxs.height = height;
+
+                let blockhash = BlockHash::from(blockhash);
+                let blockhash_prefix = BlockHashPrefix::from(&blockhash);
+
+                if trees
+                    .blockhash_prefix_to_height
+                    .get(&blockhash_prefix)?
+                    .is_some_and(|prev_height| *prev_height != height)
+                {
+                    dbg!(blockhash);
+                    return Err(eyre!("Collision, expect prefix to need be set yet"));
+                }
+
+                trees
+                    .blockhash_prefix_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())?;
+                vecs.height_to_timestamp.push_if_needed(height, Timestamp::from(block.header.time))?;
+                vecs.height_to_size.push_if_needed(height, block.total_size())?;
+                vecs.height_to_weight.push_if_needed(height, block.weight().into())?;
+
+                let inputs = block
+                    .txdata
+                    .iter()
+                    .enumerate()
+                    .flat_map(|(index, tx)| {
+                        tx.input
+                            .iter()
+                            .enumerate()
+                            .map(move |(vin, txin)| (Txindex::from(index), Vin::from(vin), txin, tx))
+                    })
+                    .collect::<Vec<_>>();
+
+                let outputs = block
+                    .txdata
+                    .iter()
+                    .enumerate()
+                    .flat_map(|(index, tx)| {
+                        tx.output
+                            .iter()
+                            .enumerate()
+                            .map(move |(vout, txout)| (Txindex::from(index), Vout::from(vout), txout, tx))
+                    })
+                    .collect::<Vec<_>>();
+
+                let tx_len = block.txdata.len();
+                let outputs_len = outputs.len();
+                let inputs_len = inputs.len();
+
+                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,
+                ) = thread::scope(|scope| {
+                    let txid_prefix_to_txid_and_block_txindex_and_prev_txindex_handle =
+                        scope.spawn(|| -> color_eyre::Result<_> {
+                            block
+                                .txdata
+                                .par_iter()
+                                .enumerate()
+                                .map(|(index, tx)| -> color_eyre::Result<_> {
+                                    let txid = Txid::from(tx.compute_txid());
+
+                                    let txid_prefix = TxidPrefix::from(&txid);
+
+                                    let prev_txindex_opt =
+                                        if check_collisions && trees.txid_prefix_to_txindex.needs(height) {
+                                            // Should only find collisions for two txids (duplicates), see below
+                                            trees.txid_prefix_to_txindex.get(&txid_prefix)?.map(|v| *v)
+                                        } else {
+                                            None
+                                        };
+
+                                    Ok((txid_prefix, (tx, txid, Txindex::from(index), prev_txindex_opt)))
+                                })
+                                .try_fold(BTreeMap::new, |mut map, tuple| {
+                                    let (key, value) = tuple?;
+                                    map.insert(key, value);
+                                    Ok(map)
+                                })
+                                .try_reduce(BTreeMap::new, |mut map, mut map2| {
+                                    if map.len() > map2.len() {
+                                        map.append(&mut map2);
+                                        Ok(map)
+                                    } else {
+                                        map2.append(&mut map);
+                                        Ok(map2)
+                                    }
+                                })
+                        });
+
+                    let input_source_vec_handle = scope.spawn(|| {
+                        inputs
+                            .into_par_iter()
+                            .enumerate()
+                            .map(|(block_txinindex, (block_txindex, vin, txin, tx))| -> color_eyre::Result<(Txinindex, InputSource)> {
+                                let txindex = idxs.txindex + block_txindex;
+                                let txinindex = idxs.txinindex + Txinindex::from(block_txinindex);
+
+                                // dbg!((txindex, txinindex, vin));
+
+                                let outpoint = txin.previous_output;
+                                let txid = Txid::from(outpoint.txid);
+
+                                if tx.is_coinbase() {
+                                    return Ok((txinindex, InputSource::SameBlock((tx, txindex, txin, vin))));
+                                }
+
+                                let prev_txindex = if let Some(txindex) = trees
+                                    .txid_prefix_to_txindex
+                                    .get(&TxidPrefix::from(&txid))?
+                                    .map(|v| *v)
+                                    .and_then(|txindex| {
+                                        // Checking if not finding txindex from the future
+                                        (txindex < idxs.txindex).then_some(txindex)
+                                    }) {
+                                    txindex
+                                } else {
+                                    // dbg!(indexes.txindex + block_txindex, txindex, txin, vin);
+                                    return Ok((txinindex, 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")
+                                    .inspect_err(|_| {
+                                        dbg!(outpoint.txid, prev_txindex, vout);
+                                    })?
+                                    + vout;
+
+                                Ok((txinindex, InputSource::PreviousBlock((
+                                    vin,
+                                    txindex,
+                                    txoutindex,
+                                ))))
+                            })
+                            .try_fold(BTreeMap::new, |mut map, tuple| -> color_eyre::Result<_> {
+                                let (key, value) = tuple?;
+                                map.insert(key, value);
+                                Ok(map)
+                            })
+                            .try_reduce(BTreeMap::new, |mut map, mut map2| {
+                                if map.len() > map2.len() {
+                                    map.append(&mut map2);
+                                    Ok(map)
+                                } else {
+                                    map2.append(&mut map);
+                                    Ok(map2)
+                                }
+                            })
+                    });
+
+                    let txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt_handle = scope.spawn(|| {
+                        outputs
+                            .into_par_iter()
+                            .enumerate()
+                            .map(
+                                #[allow(clippy::type_complexity)]
+                                |(block_txoutindex, (block_txindex, vout, txout, tx))| -> color_eyre::Result<(
+                                    Txoutindex,
+                                    (
+                                        &TxOut,
+                                        Txindex,
+                                        Vout,
+                                        Addresstype,
+                                        color_eyre::Result<Addressbytes>,
+                                        Option<Addressindex>,
+                                        &Transaction,
+                                    ),
+                                )> {
+                                    let txindex = idxs.txindex + block_txindex;
+                                    let txoutindex = idxs.txoutindex + Txoutindex::from(block_txoutindex);
+
+                                    let script = &txout.script_pubkey;
+
+                                    let addresstype = Addresstype::from(script);
+
+                                    let addressbytes_res =
+                                        Addressbytes::try_from((script, addresstype)).inspect_err(|_| {
+                                            // dbg!(&txout, height, txi, &tx.compute_txid());
+                                        });
+
+                                    let addressindex_opt = addressbytes_res.as_ref().ok().and_then(|addressbytes| {
+                                        trees
+                                            .addresshash_to_addressindex
+                                            .get(&AddressHash::from((addressbytes, addresstype)))
+                                            .unwrap()
+                                            .map(|v| *v)
+                                            // Checking if not in the future
+                                            .and_then(|addressindex_local| {
+                                                (addressindex_local < idxs.addressindex).then_some(addressindex_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)?;
+
+                                        let prev_addressbytes =
+                                            prev_addressbytes_opt.as_ref().context("Expect to have addressbytes")?;
+
+                                        if (vecs.addressindex_to_addresstype.hasnt(addressindex)?
+                                            && addresstype != prev_addresstype)
+                                            || (trees.addresshash_to_addressindex.needs(height)
+                                                && prev_addressbytes != addressbytes)
+                                        {
+                                            let txid = tx.compute_txid();
+                                            dbg!(
+                                                height,
+                                                txid,
+                                                vout,
+                                                block_txindex,
+                                                addresstype,
+                                                prev_addresstype,
+                                                prev_addressbytes,
+                                                addressbytes,
+                                                idxs.addressindex,
+                                                addressindex,
+                                                addresstypeindex,
+                                                txout,
+                                                AddressHash::from((addressbytes, addresstype)),
+                                                AddressHash::from((prev_addressbytes, prev_addresstype))
+                                            );
+                                            panic!()
+                                        }
+                                    }
+
+                                    Ok((
+                                        txoutindex,
+                                        (
+                                            txout,
+                                            txindex,
+                                            vout,
+                                            addresstype,
+                                            addressbytes_res,
+                                            addressindex_opt,
+                                            tx,
+                                        ),
+                                    ))
+                                },
+                            )
+                            .try_fold(BTreeMap::new, |mut map, tuple| -> color_eyre::Result<_> {
+                                let (key, value) = tuple?;
+                                map.insert(key, value);
+                                Ok(map)
+                            })
+                            .try_reduce(BTreeMap::new, |mut map, mut map2| {
+                                if map.len() > map2.len() {
+                                    map.append(&mut map2);
+                                    Ok(map)
+                                } else {
+                                    map2.append(&mut map);
+                                    Ok(map2)
+                                }
+                            })
+                    });
+
+                    (
+                        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(),
+                    )
+                });
+
+                let txid_prefix_to_txid_and_block_txindex_and_prev_txindex =
+                    txid_prefix_to_txid_and_block_txindex_and_prev_txindex_join_handle
+                        .ok()
+                        .context(
+                            "Expect txid_prefix_to_txid_and_block_txindex_and_prev_txindex_join_handle to join",
+                        )??;
+
+                let input_source_vec = input_source_vec_handle
+                    .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
+                        .ok()
+                        .context(
+                            "Expect txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt_handle to join",
+                        )??;
+
+                let mut new_txindexvout_to_txoutindex: BTreeMap<
+                    (Txindex, Vout),
+                    Txoutindex,
+                > = BTreeMap::new();
+
+                let mut already_added_addresshash: BTreeMap<AddressHash, Addressindex> = BTreeMap::new();
+
+                txoutindex_to_txout_addresstype_addressbytes_res_addressindex_opt
+                .into_iter()
+                .try_for_each(
+                    |(
+                        txoutindex,
+                        (txout, txindex, vout, addresstype, addressbytes_res, addressindex_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.txoutindex_to_value.push_if_needed(txoutindex, sats)?;
+
+                        let mut addressindex = idxs.addressindex;
+
+                        let mut addresshash = None;
+
+                        if let Some(addressindex_local) = addressindex_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())
+                                    .cloned()
+                            })
+                        }) {
+                            addressindex = addressindex_local;
+                        } else {
+                            idxs.addressindex.increment();
+
+                            let addresstypeindex = match addresstype {
+                                Addresstype::Empty => idxs.emptyindex.copy_then_increment(),
+                                Addresstype::Multisig => idxs.multisigindex.copy_then_increment(),
+                                Addresstype::OpReturn => idxs.opreturnindex.copy_then_increment(),
+                                Addresstype::PushOnly => idxs.pushonlyindex.copy_then_increment(),
+                                Addresstype::Unknown => idxs.unknownindex.copy_then_increment(),
+                                Addresstype::P2PK65 => idxs.p2pk65index.copy_then_increment(),
+                                Addresstype::P2PK33 => idxs.p2pk33index.copy_then_increment(),
+                                Addresstype::P2PKH => idxs.p2pkhindex.copy_then_increment(),
+                                Addresstype::P2SH => idxs.p2shindex.copy_then_increment(),
+                                Addresstype::P2WPKH => idxs.p2wpkhindex.copy_then_increment(),
+                                Addresstype::P2WSH => idxs.p2wshindex.copy_then_increment(),
+                                Addresstype::P2TR => idxs.p2trindex.copy_then_increment(),
+                            };
+
+                            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();
+
+                                already_added_addresshash
+                                    .insert(addresshash, addressindex);
+
+                                trees.addresshash_to_addressindex.insert_if_needed(
+                                    addresshash,
+                                    addressindex,
+                                    height,
+                                );
+
+                                vecs.push_addressbytes_if_needed(addresstypeindex, addressbytes)?;
+                            }
+                        }
+
+                        new_txindexvout_to_txoutindex
+                            .insert((txindex, vout), txoutindex);
+
+                        vecs.txoutindex_to_addressindex
+                            .push_if_needed(txoutindex, addressindex)?;
+
+                        Ok(())
+                    },
+                )?;
+
+                drop(already_added_addresshash);
+
+                input_source_vec
+                    .into_iter()
+                    .map(
+                        #[allow(clippy::type_complexity)]
+                        |(txinindex, input_source)| -> color_eyre::Result<(
+                            Txinindex, Vin, Txindex, Txoutindex
+                        )> {
+                            match input_source {
+                                InputSource::PreviousBlock((vin, txindex, txoutindex)) => Ok((txinindex, vin, txindex, txoutindex)),
+                                InputSource::SameBlock((tx, txindex, txin, vin)) => {
+                                    if tx.is_coinbase() {
+                                        return Ok((txinindex, vin, txindex, Txoutindex::COINBASE));
+                                    }
+
+                                    let outpoint = txin.previous_output;
+                                    let txid = Txid::from(outpoint.txid);
+                                    let vout = Vout::from(outpoint.vout);
+
+                                    let block_txindex = txid_prefix_to_txid_and_block_txindex_and_prev_txindex
+                                        .get(&TxidPrefix::from(&txid))
+                                        .context("txid should be in same block").inspect_err(|_| {
+                                            dbg!(&txid_prefix_to_txid_and_block_txindex_and_prev_txindex);
+                                            // panic!();
+                                        })?
+                                        .2;
+                                    let prev_txindex = idxs.txindex + block_txindex;
+
+                                    let prev_txoutindex = new_txindexvout_to_txoutindex
+                                        .remove(&(prev_txindex, vout))
+                                        .context("should have found addressindex from same block")
+                                        .inspect_err(|_| {
+                                            dbg!(&new_txindexvout_to_txoutindex, txin, prev_txindex, vout, txid);
+                                        })?;
+
+                                    Ok((txinindex, vin, txindex, prev_txoutindex))
+                                }
+                            }
+                        },
+                    )
+                    .try_for_each(|res| -> color_eyre::Result<()> {
+                        let (txinindex, vin, txindex, txoutindex) = res?;
+
+                        if vin.is_zero() {
+                            vecs.txindex_to_first_txinindex.push_if_needed(txindex, txinindex)?;
+                        }
+
+                        vecs.txinindex_to_txoutindex.push_if_needed(txinindex, txoutindex)?;
+
+                        Ok(())
+                    })?;
+
+                drop(new_txindexvout_to_txoutindex);
+
+                let mut txindex_to_tx_and_txid: BTreeMap<Txindex, (&Transaction, Txid)> = BTreeMap::default();
+
+                txid_prefix_to_txid_and_block_txindex_and_prev_txindex
+                    .into_iter()
+                    .try_for_each(
+                        |(txid_prefix, (tx, txid, index, prev_txindex_opt))| -> color_eyre::Result<()> {
+                            let txindex = idxs.txindex + index;
+
+                            txindex_to_tx_and_txid.insert(txindex, (tx, txid));
+
+                            match prev_txindex_opt {
+                                None => {
+                                    trees
+                                        .txid_prefix_to_txindex
+                                        .insert_if_needed(txid_prefix, txindex, height);
+                                }
+                                Some(prev_txindex) => {
+                                    // In case if we start at an already parsed height
+                                    if txindex == prev_txindex {
+                                        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)?
+                                        .context("To have txid for txindex")
+                                        .inspect_err(|_| {
+                                            dbg!(txindex, len);
+                                        })?;
+
+                                    // #[allow(clippy::redundant_locals)]
+                                    // let prev_txid = prev_txid;
+                                    let prev_txid = prev_txid.as_ref();
+
+                                    // If another Txid needs to be added to the list
+                                    // We need to check that it's also a coinbase tx otherwise par_iter inputs needs to be updated
+                                    let only_known_dup_txids = [
+                                        bitcoin::Txid::from_str(
+                                            "d5d27987d2a3dfc724e359870c6644b40e497bdc0589a033220fe15429d88599",
+                                        )?.into(),
+                                        bitcoin::Txid::from_str(
+                                            "e3bf3d07d4b0375638d5f1db5255fe07ba2c4cb067cd81b84ee974b6585fb468",
+                                        )?.into(),
+                                    ];
+
+                                    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);
+                                        return Err(eyre!("Expect none"));
+                                    }
+                                }
+                            }
+
+                            Ok(())
+                        },
+                    )?;
+
+                txindex_to_tx_and_txid
+                    .into_iter()
+                    .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_is_explicitly_rbf.push_if_needed(txindex, tx.is_explicitly_rbf())?;
+                        Ok(())
+                    })?;
+
+                idxs.txindex += Txindex::from(tx_len);
+                idxs.txinindex += Txinindex::from(inputs_len);
+                idxs.txoutindex += Txoutindex::from(outputs_len);
+
+                idxs.push_future_if_needed(vecs)?;
+
+                let should_snapshot = height != 0 && height % SNAPSHOT_BLOCK_RANGE == 0 && !exit.blocked();
+                if should_snapshot {
+                    export(trees, vecs, height)?;
+                }
+
+                Ok(())
+            })?;
+
+        export(trees, vecs, idxs.height)?;
+
+        sleep(Duration::from_millis(100));
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+enum InputSource<'a> {
+    PreviousBlock((Vin, Txindex, Txoutindex)),
+    SameBlock((&'a Transaction, Txindex, &'a TxIn, Vin)),
+}

crates/brk_indexer/src/main.rs

@@ -0,0 +1,40 @@
+use std::{path::Path, thread::sleep, time::Duration};
+
+use brk_indexer::{Indexer, rpc::RpcApi};
+use brk_parser::rpc::{self};
+use hodor::Exit;
+use log::info;
+use storable_vec::CACHED_GETS;
+
+fn main() -> color_eyre::Result<()> {
+    color_eyre::install()?;
+
+    brk_printer::init_log(None);
+
+    let data_dir = Path::new("../../bitcoin");
+    let rpc = Box::leak(Box::new(rpc::Client::new(
+        "http://localhost:8332",
+        rpc::Auth::CookieFile(Path::new(data_dir).join(".cookie")),
+    )?));
+    let exit = Exit::new();
+
+    loop {
+        let block_count = rpc.get_blockchain_info().unwrap().blocks as usize;
+
+        info!("{block_count} blocks found.");
+
+        let i = std::time::Instant::now();
+
+        let mut indexer: Indexer<CACHED_GETS> = Indexer::import(Path::new("../_outputs/indexes"))?;
+
+        indexer.index(data_dir, rpc, &exit)?;
+
+        dbg!(i.elapsed());
+
+        info!("Waiting for a new block...");
+
+        while block_count == rpc.get_blockchain_info().unwrap().blocks as usize {
+            sleep(Duration::from_secs(1))
+        }
+    }
+}

crates/brk_indexer/src/storage/fjalls/base.rs

@@ -0,0 +1,149 @@
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    error, mem,
+    path::Path,
+};
+
+use brk_parser::Height;
+use fjall::{
+    PartitionCreateOptions, PersistMode, ReadTransaction, Result, Slice, TransactionalKeyspace,
+    TransactionalPartitionHandle,
+};
+use storable_vec::{Value, Version};
+use zerocopy::{Immutable, IntoBytes};
+
+use super::StoreMeta;
+
+pub struct Store<Key, Value> {
+    meta: StoreMeta,
+    keyspace: TransactionalKeyspace,
+    part: TransactionalPartitionHandle,
+    rtx: ReadTransaction,
+    puts: BTreeMap<Key, Value>,
+    dels: BTreeSet<Key>,
+}
+
+const CHECK_COLLISISONS: bool = true;
+
+impl<K, V> Store<K, V>
+where
+    K: Into<Slice> + Ord + Immutable + IntoBytes,
+    V: Into<Slice> + TryFrom<Slice>,
+    <V as TryFrom<Slice>>::Error: error::Error + Send + Sync + 'static,
+{
+    pub fn import(path: &Path, version: Version) -> color_eyre::Result<Self> {
+        let meta = StoreMeta::checked_open(path, version)?;
+        let keyspace = if let Ok(keyspace) = Self::open_keyspace(path) {
+            keyspace
+        } else {
+            meta.reset()?;
+            return Self::import(path, version);
+        };
+        let part = if let Ok(part) = Self::open_partition_handle(&keyspace) {
+            part
+        } else {
+            drop(keyspace);
+            meta.reset()?;
+            return Self::import(path, version);
+        };
+        let rtx = keyspace.read_tx();
+
+        Ok(Self {
+            meta,
+            keyspace,
+            part,
+            rtx,
+            puts: BTreeMap::new(),
+            dels: BTreeSet::new(),
+        })
+    }
+
+    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())? {
+            Ok(Some(Value::Owned(V::try_from(slice)?)))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn insert_if_needed(&mut self, key: K, value: V, height: Height) {
+        if self.needs(height) {
+            if !self.dels.is_empty() {
+                unreachable!("Shouldn't reach this");
+                // self.dels.remove(&key);
+            }
+            self.puts.insert(key, value);
+        }
+    }
+
+    pub fn remove(&mut self, key: K) {
+        if !self.puts.is_empty() {
+            unreachable!("Shouldn't reach this");
+            // self.puts.remove(&key);
+        }
+        self.dels.insert(key);
+    }
+
+    pub fn commit(&mut self, height: Height) -> Result<()> {
+        if self.has(height) && self.puts.is_empty() && self.dels.is_empty() {
+            return Ok(());
+        }
+
+        self.meta.export(self.len(), height)?;
+
+        let mut wtx = self.keyspace.write_tx();
+
+        mem::take(&mut self.dels)
+            .into_iter()
+            .for_each(|key| wtx.remove(&self.part, key));
+
+        mem::take(&mut self.puts).into_iter().for_each(|(key, value)| {
+            if CHECK_COLLISISONS {
+                if let Ok(Some(value)) = wtx.get(&self.part, key.as_bytes()) {
+                    dbg!(value, &self.meta);
+                    unreachable!();
+                }
+            }
+            wtx.insert(&self.part, key, value)
+        });
+
+        wtx.commit()?;
+
+        self.keyspace.persist(PersistMode::SyncAll)?;
+
+        self.rtx = self.keyspace.read_tx();
+
+        Ok(())
+    }
+
+    pub fn height(&self) -> Option<Height> {
+        self.meta.height()
+    }
+
+    pub fn len(&self) -> usize {
+        self.meta.len() + self.puts.len() - self.dels.len()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn has(&self, height: Height) -> bool {
+        self.meta.has(height)
+    }
+    pub fn needs(&self, height: Height) -> bool {
+        self.meta.needs(height)
+    }
+
+    fn open_keyspace(path: &Path) -> Result<TransactionalKeyspace> {
+        fjall::Config::new(path.join("fjall")).open_transactional()
+    }
+
+    fn open_partition_handle(keyspace: &TransactionalKeyspace) -> Result<TransactionalPartitionHandle> {
+        keyspace.open_partition(
+            "partition",
+            PartitionCreateOptions::default().manual_journal_persist(true),
+        )
+    }
+}

crates/brk_indexer/src/storage/fjalls/meta.rs

@@ -0,0 +1,104 @@
+use std::{
+    fs, io,
+    path::{Path, PathBuf},
+};
+
+use storable_vec::Version;
+use zerocopy::{FromBytes, IntoBytes};
+
+use super::Height;
+
+#[derive(Debug)]
+pub struct StoreMeta {
+    pathbuf: PathBuf,
+    version: Version,
+    height: Option<Height>,
+    len: usize,
+}
+
+impl StoreMeta {
+    pub fn checked_open(path: &Path, version: Version) -> color_eyre::Result<Self> {
+        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);
+
+        if !is_same_version {
+            Self::reset_(path)?;
+        }
+
+        let this = Self {
+            pathbuf: path.to_owned(),
+            version,
+            height: Height::try_from(Self::path_height_(path).as_path()).ok(),
+            len: Self::read_length_(path)?,
+        };
+
+        this.version.write(&this.path_version())?;
+
+        Ok(this)
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn export(&mut self, len: usize, height: Height) -> io::Result<()> {
+        self.len = len;
+        self.write_length()?;
+        self.height = Some(height);
+        height.write(&self.path_height())
+    }
+
+    pub fn reset(&self) -> io::Result<()> {
+        Self::reset_(self.pathbuf.as_path())
+    }
+    fn reset_(path: &Path) -> io::Result<()> {
+        fs::remove_dir_all(path)?;
+        fs::create_dir(path)
+    }
+
+    fn path_version(&self) -> PathBuf {
+        Self::path_version_(&self.pathbuf)
+    }
+    fn path_version_(path: &Path) -> PathBuf {
+        path.join("version")
+    }
+
+    pub fn height(&self) -> Option<Height> {
+        self.height
+    }
+    pub fn needs(&self, height: Height) -> bool {
+        self.height.is_none_or(|self_height| height > self_height)
+    }
+    pub fn has(&self, height: Height) -> bool {
+        !self.needs(height)
+    }
+    fn path_height(&self) -> PathBuf {
+        Self::path_height_(&self.pathbuf)
+    }
+    fn path_height_(path: &Path) -> PathBuf {
+        path.join("height")
+    }
+
+    // fn read_length(&self) -> color_eyre::Result<usize> {
+    //     Self::read_length_(&self.pathbuf)
+    // }
+    fn read_length_(path: &Path) -> color_eyre::Result<usize> {
+        Ok(fs::read(Self::path_length(path))
+            .map(|v| usize::read_from_bytes(v.as_slice()).unwrap_or_default())
+            .unwrap_or_default())
+    }
+    fn write_length(&self) -> io::Result<()> {
+        Self::write_length_(&self.pathbuf, self.len)
+    }
+    fn write_length_(path: &Path, len: usize) -> Result<(), io::Error> {
+        fs::write(Self::path_length(path), len.as_bytes())
+    }
+    fn path_length(path: &Path) -> PathBuf {
+        path.join("length")
+    }
+}

crates/brk_indexer/src/storage/fjalls/mod.rs

@@ -0,0 +1,182 @@
+use std::{path::Path, thread};
+
+use storable_vec::{Value, Version, CACHED_GETS};
+
+use crate::{
+    AddressHash, Addressbytes, Addressindex, Addresstype, BlockHashPrefix, Height, Indexes, TxidPrefix, Txindex,
+};
+
+mod base;
+mod meta;
+
+pub use base::*;
+pub use meta::*;
+
+use super::StorableVecs;
+
+pub struct Fjalls {
+    pub addresshash_to_addressindex: Store<AddressHash, Addressindex>,
+    pub blockhash_prefix_to_height: Store<BlockHashPrefix, Height>,
+    pub txid_prefix_to_txindex: Store<TxidPrefix, Txindex>,
+}
+
+impl Fjalls {
+    pub fn import(path: &Path) -> color_eyre::Result<Self> {
+        let addresshash_to_addressindex = Store::import(&path.join("addresshash_to_addressindex"), Version::from(1))?;
+        let blockhash_prefix_to_height = Store::import(&path.join("blockhash_prefix_to_height"), Version::from(1))?;
+        let txid_prefix_to_txindex = Store::import(&path.join("txid_prefix_to_txindex"), Version::from(1))?;
+
+        Ok(Self {
+            addresshash_to_addressindex,
+            blockhash_prefix_to_height,
+            txid_prefix_to_txindex,
+        })
+    }
+
+    pub fn rollback(&mut self, vecs: &StorableVecs<CACHED_GETS>, starting_indexes: &Indexes) -> color_eyre::Result<()> {
+        vecs.height_to_blockhash
+            .iter_from(starting_indexes.height, |(_, blockhash)| {
+                let blockhash = blockhash.as_ref();
+                let blockhash_prefix = BlockHashPrefix::from(blockhash);
+                self.blockhash_prefix_to_height.remove(blockhash_prefix);
+                Ok(())
+            })?;
+
+        vecs.txindex_to_txid.iter_from(starting_indexes.txindex, |(_, txid)| {
+            let txid = txid.as_ref();
+            let txid_prefix = TxidPrefix::from(txid);
+            self.txid_prefix_to_txindex.remove(txid_prefix);
+            Ok(())
+        })?;
+
+        vecs.height_to_first_p2pk65index
+            .iter_from(starting_indexes.height, |(_, index)| {
+                if let Some(typedbytes) = vecs
+                    .p2pk65index_to_p2pk65addressbytes
+                    .get(index.into_inner())?
+                    .map(Value::into_inner)
+                {
+                    let bytes = Addressbytes::from(typedbytes);
+                    let hash = AddressHash::from((&bytes, Addresstype::P2PK65));
+                    self.addresshash_to_addressindex.remove(hash);
+                }
+                Ok(())
+            })?;
+
+        vecs.height_to_first_p2pk33index
+            .iter_from(starting_indexes.height, |(_, index)| {
+                if let Some(typedbytes) = vecs
+                    .p2pk33index_to_p2pk33addressbytes
+                    .get(index.into_inner())?
+                    .map(Value::into_inner)
+                {
+                    let bytes = Addressbytes::from(typedbytes);
+                    let hash = AddressHash::from((&bytes, Addresstype::P2PK33));
+                    self.addresshash_to_addressindex.remove(hash);
+                }
+                Ok(())
+            })?;
+
+        vecs.height_to_first_p2pkhindex
+            .iter_from(starting_indexes.height, |(_, index)| {
+                if let Some(typedbytes) = vecs
+                    .p2pkhindex_to_p2pkhaddressbytes
+                    .get(index.into_inner())?
+                    .map(Value::into_inner)
+                {
+                    let bytes = Addressbytes::from(typedbytes);
+                    let hash = AddressHash::from((&bytes, Addresstype::P2PKH));
+                    self.addresshash_to_addressindex.remove(hash);
+                }
+                Ok(())
+            })?;
+
+        vecs.height_to_first_p2shindex
+            .iter_from(starting_indexes.height, |(_, index)| {
+                if let Some(typedbytes) = vecs
+                    .p2shindex_to_p2shaddressbytes
+                    .get(index.into_inner())?
+                    .map(Value::into_inner)
+                {
+                    let bytes = Addressbytes::from(typedbytes);
+                    let hash = AddressHash::from((&bytes, Addresstype::P2SH));
+                    self.addresshash_to_addressindex.remove(hash);
+                }
+                Ok(())
+            })?;
+
+        vecs.height_to_first_p2trindex
+            .iter_from(starting_indexes.height, |(_, index)| {
+                if let Some(typedbytes) = vecs
+                    .p2trindex_to_p2traddressbytes
+                    .get(index.into_inner())?
+                    .map(Value::into_inner)
+                {
+                    let bytes = Addressbytes::from(typedbytes);
+                    let hash = AddressHash::from((&bytes, Addresstype::P2TR));
+                    self.addresshash_to_addressindex.remove(hash);
+                }
+                Ok(())
+            })?;
+
+        vecs.height_to_first_p2wpkhindex
+            .iter_from(starting_indexes.height, |(_, index)| {
+                if let Some(typedbytes) = vecs
+                    .p2wpkhindex_to_p2wpkhaddressbytes
+                    .get(index.into_inner())?
+                    .map(Value::into_inner)
+                {
+                    let bytes = Addressbytes::from(typedbytes);
+                    let hash = AddressHash::from((&bytes, Addresstype::P2WPKH));
+                    self.addresshash_to_addressindex.remove(hash);
+                }
+                Ok(())
+            })?;
+
+        vecs.height_to_first_p2wshindex
+            .iter_from(starting_indexes.height, |(_, index)| {
+                if let Some(typedbytes) = vecs
+                    .p2wshindex_to_p2wshaddressbytes
+                    .get(index.into_inner())?
+                    .map(Value::into_inner)
+                {
+                    let bytes = Addressbytes::from(typedbytes);
+                    let hash = AddressHash::from((&bytes, Addresstype::P2WSH));
+                    self.addresshash_to_addressindex.remove(hash);
+                }
+                Ok(())
+            })?;
+
+        self.commit(starting_indexes.height.decremented())?;
+
+        Ok(())
+    }
+
+    pub fn starting_height(&self) -> Height {
+        [
+            self.addresshash_to_addressindex.height(),
+            self.blockhash_prefix_to_height.height(),
+            self.txid_prefix_to_txindex.height(),
+        ]
+        .into_iter()
+        .map(|height| height.map(Height::incremented).unwrap_or_default())
+        .min()
+        .unwrap()
+    }
+
+    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));
+
+            addresshash_to_addressindex_commit_handle.join().unwrap()?;
+            blockhash_prefix_to_height_commit_handle.join().unwrap()?;
+            txid_prefix_to_txindex_commit_handle.join().unwrap()?;
+
+            Ok(())
+        })
+    }
+}

crates/brk_indexer/src/storage/fjalls/version.rs

@@ -0,0 +1,51 @@
+use std::{fs, io, path::Path};
+
+use derive_deref::Deref;
+use fjall::Slice;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Deref)]
+pub struct Version(u32);
+
+impl Version {
+    pub fn write(&self, path: &Path) -> Result<(), io::Error> {
+        fs::write(path, self.to_ne_bytes())
+    }
+}
+
+impl From<u32> for Version {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl TryFrom<&Path> for Version {
+    type Error = io::Error;
+    fn try_from(value: &Path) -> Result<Self, Self::Error> {
+        Self::try_from(&fs::read(value)?)
+    }
+}
+impl TryFrom<Slice> for Version {
+    type Error = fjall::Error;
+    fn try_from(value: Slice) -> Result<Self, Self::Error> {
+        Self::from(&value)
+    }
+}
+impl TryFrom<&[u8]> for Version {
+    type Error = storable_vec::Error;
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        let mut buf: [u8; 4] = [0; 4];
+        let buf_len = buf.len();
+        if value.len() != buf_len {
+            panic!();
+        }
+        value.iter().enumerate().for_each(|(i, r)| {
+            buf[i] = *r;
+        });
+        Ok(Self(u32::from_ne_bytes(buf)))
+    }
+}
+impl From<Version> for Slice {
+    fn from(value: Version) -> Self {
+        Self::new(&value.to_ne_bytes())
+    }
+}

crates/brk_indexer/src/storage/mod.rs

@@ -0,0 +1,9 @@
+// mod canopy;
+mod fjalls;
+// mod sanakirja;
+mod storable_vecs;
+
+// pub use canopy::*;
+pub use fjalls::*;
+// pub use sanakirja::*;
+pub use storable_vecs::*;

crates/brk_indexer/src/storage/storable_vecs/base.rs

@@ -0,0 +1,90 @@
+use std::{
+    fmt::Debug,
+    io,
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+};
+
+use storable_vec::{StoredIndex, StoredType, Version};
+
+use super::Height;
+
+#[derive(Debug)]
+pub struct StorableVec<I, T, const MODE: u8> {
+    height: Option<Height>,
+    vec: storable_vec::StorableVec<I, T, MODE>,
+}
+
+impl<I, T, const MODE: u8> StorableVec<I, T, MODE>
+where
+    I: StoredIndex,
+    T: StoredType,
+{
+    pub fn import(path: &Path, version: Version) -> storable_vec::Result<Self> {
+        Ok(Self {
+            height: Height::try_from(Self::path_height_(path).as_path()).ok(),
+            vec: storable_vec::StorableVec::forced_import(path, version)?,
+        })
+    }
+
+    pub fn flush(&mut self, height: Height) -> io::Result<()> {
+        height.write(&self.path_height())?;
+        self.vec.flush()
+    }
+
+    pub fn truncate_if_needed(&mut self, index: I, height: Height) -> storable_vec::Result<Option<T>> {
+        if self.height.is_none_or(|self_height| self_height != height) {
+            height.write(&self.path_height())?;
+        }
+        self.vec.truncate_if_needed(index)
+    }
+
+    pub fn height(&self) -> brk_parser::Result<Height> {
+        Height::try_from(self.path_height().as_path())
+    }
+    fn path_height(&self) -> PathBuf {
+        Self::path_height_(self.vec.path())
+    }
+    fn path_height_(path: &Path) -> PathBuf {
+        path.join("height")
+    }
+
+    pub fn needs(&self, height: Height) -> bool {
+        self.height.is_none_or(|self_height| height > self_height)
+    }
+    #[allow(unused)]
+    pub fn has(&self, height: Height) -> bool {
+        !self.needs(height)
+    }
+}
+
+impl<I, T, const MODE: u8> Deref for StorableVec<I, T, MODE> {
+    type Target = storable_vec::StorableVec<I, T, MODE>;
+    fn deref(&self) -> &Self::Target {
+        &self.vec
+    }
+}
+impl<I, T, const MODE: u8> DerefMut for StorableVec<I, T, MODE> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.vec
+    }
+}
+
+pub trait AnyStorableVec: Send + Sync {
+    fn height(&self) -> brk_parser::Result<Height>;
+    fn flush(&mut self, height: Height) -> io::Result<()>;
+}
+
+impl<I, T, const MODE: u8> AnyStorableVec for StorableVec<I, T, MODE>
+where
+    I: StoredIndex,
+    T: StoredType,
+{
+    fn height(&self) -> brk_parser::Result<Height> {
+        self.height()
+    }
+
+    fn flush(&mut self, height: Height) -> io::Result<()> {
+        self.flush(height)
+    }
+}

crates/brk_indexer/src/storage/storable_vecs/mod.rs

@@ -0,0 +1,478 @@
+use std::{fs, io, path::Path};
+
+use brk_parser::Height;
+use rayon::prelude::*;
+use storable_vec::{AnyJsonStorableVec, CACHED_GETS, Version};
+
+use crate::{
+    Indexes,
+    structs::{
+        Addressbytes, Addressindex, Addresstype, Addresstypeindex, BlockHash, Emptyindex, LockTime, Multisigindex,
+        Opreturnindex, P2PK33AddressBytes, P2PK33index, P2PK65AddressBytes, P2PK65index, P2PKHAddressBytes, P2PKHindex,
+        P2SHAddressBytes, P2SHindex, P2TRAddressBytes, P2TRindex, P2WPKHAddressBytes, P2WPKHindex, P2WSHAddressBytes,
+        P2WSHindex, Pushonlyindex, Sats, Timestamp, TxVersion, Txid, Txindex, Txinindex, Txoutindex, Unknownindex,
+        Weight,
+    },
+};
+
+mod base;
+
+pub use base::*;
+
+pub struct StorableVecs<const MODE: u8> {
+    pub addressindex_to_addresstype: StorableVec<Addressindex, Addresstype, MODE>,
+    pub addressindex_to_addresstypeindex: StorableVec<Addressindex, Addresstypeindex, MODE>,
+    pub addressindex_to_height: StorableVec<Addressindex, Height, MODE>,
+    pub height_to_blockhash: StorableVec<Height, BlockHash, MODE>,
+    pub height_to_difficulty: StorableVec<Height, f64, MODE>,
+    pub height_to_first_addressindex: StorableVec<Height, Addressindex, MODE>,
+    pub height_to_first_emptyindex: StorableVec<Height, Emptyindex, MODE>,
+    pub height_to_first_multisigindex: StorableVec<Height, Multisigindex, MODE>,
+    pub height_to_first_opreturnindex: StorableVec<Height, Opreturnindex, MODE>,
+    pub height_to_first_pushonlyindex: StorableVec<Height, Pushonlyindex, MODE>,
+    pub height_to_first_txindex: StorableVec<Height, Txindex, MODE>,
+    pub height_to_first_txinindex: StorableVec<Height, Txinindex, MODE>,
+    pub height_to_first_txoutindex: StorableVec<Height, Txoutindex, MODE>,
+    pub height_to_first_unknownindex: StorableVec<Height, Unknownindex, MODE>,
+    pub height_to_first_p2pk33index: StorableVec<Height, P2PK33index, MODE>,
+    pub height_to_first_p2pk65index: StorableVec<Height, P2PK65index, MODE>,
+    pub height_to_first_p2pkhindex: StorableVec<Height, P2PKHindex, MODE>,
+    pub height_to_first_p2shindex: StorableVec<Height, P2SHindex, MODE>,
+    pub height_to_first_p2trindex: StorableVec<Height, P2TRindex, MODE>,
+    pub height_to_first_p2wpkhindex: StorableVec<Height, P2WPKHindex, MODE>,
+    pub height_to_first_p2wshindex: StorableVec<Height, P2WSHindex, MODE>,
+    pub height_to_size: StorableVec<Height, usize, MODE>,
+    pub height_to_timestamp: StorableVec<Height, Timestamp, MODE>,
+    pub height_to_weight: StorableVec<Height, Weight, MODE>,
+    pub p2pk33index_to_p2pk33addressbytes: StorableVec<P2PK33index, P2PK33AddressBytes, MODE>,
+    pub p2pk65index_to_p2pk65addressbytes: StorableVec<P2PK65index, P2PK65AddressBytes, MODE>,
+    pub p2pkhindex_to_p2pkhaddressbytes: StorableVec<P2PKHindex, P2PKHAddressBytes, MODE>,
+    pub p2shindex_to_p2shaddressbytes: StorableVec<P2SHindex, P2SHAddressBytes, MODE>,
+    pub p2trindex_to_p2traddressbytes: StorableVec<P2TRindex, P2TRAddressBytes, MODE>,
+    pub p2wpkhindex_to_p2wpkhaddressbytes: StorableVec<P2WPKHindex, P2WPKHAddressBytes, MODE>,
+    pub p2wshindex_to_p2wshaddressbytes: StorableVec<P2WSHindex, P2WSHAddressBytes, MODE>,
+    pub txindex_to_first_txinindex: StorableVec<Txindex, Txinindex, MODE>,
+    pub txindex_to_first_txoutindex: StorableVec<Txindex, Txoutindex, MODE>,
+    pub txindex_to_height: StorableVec<Txindex, Height, MODE>,
+    pub txindex_to_locktime: StorableVec<Txindex, LockTime, MODE>,
+    pub txindex_to_txid: StorableVec<Txindex, Txid, MODE>,
+    pub txindex_to_base_size: StorableVec<Txindex, usize, MODE>,
+    pub txindex_to_total_size: StorableVec<Txindex, usize, MODE>,
+    pub txindex_to_is_explicitly_rbf: StorableVec<Txindex, bool, MODE>,
+    pub txindex_to_txversion: StorableVec<Txindex, TxVersion, MODE>,
+    pub txinindex_to_txoutindex: StorableVec<Txinindex, Txoutindex, MODE>,
+    pub txoutindex_to_addressindex: StorableVec<Txoutindex, Addressindex, MODE>,
+    pub txoutindex_to_value: StorableVec<Txoutindex, Sats, MODE>,
+}
+
+impl<const MODE: u8> StorableVecs<MODE> {
+    pub fn import(path: &Path) -> color_eyre::Result<Self> {
+        fs::create_dir_all(path)?;
+
+        Ok(Self {
+            addressindex_to_addresstype: StorableVec::import(
+                &path.join("addressindex_to_addresstype"),
+                Version::from(1),
+            )?,
+            addressindex_to_addresstypeindex: StorableVec::import(
+                &path.join("addressindex_to_addresstypeindex"),
+                Version::from(1),
+            )?,
+            addressindex_to_height: StorableVec::import(&path.join("addressindex_to_height"), Version::from(1))?,
+            height_to_blockhash: StorableVec::import(&path.join("height_to_blockhash"), Version::from(1))?,
+            height_to_difficulty: StorableVec::import(&path.join("height_to_difficulty"), Version::from(1))?,
+            height_to_first_addressindex: StorableVec::import(
+                &path.join("height_to_first_addressindex"),
+                Version::from(1),
+            )?,
+            height_to_first_emptyindex: StorableVec::import(
+                &path.join("height_to_first_emptyindex"),
+                Version::from(1),
+            )?,
+            height_to_first_multisigindex: StorableVec::import(
+                &path.join("height_to_first_multisigindex"),
+                Version::from(1),
+            )?,
+            height_to_first_opreturnindex: StorableVec::import(
+                &path.join("height_to_first_opreturnindex"),
+                Version::from(1),
+            )?,
+            height_to_first_pushonlyindex: StorableVec::import(
+                &path.join("height_to_first_pushonlyindex"),
+                Version::from(1),
+            )?,
+            height_to_first_txindex: StorableVec::import(&path.join("height_to_first_txindex"), Version::from(1))?,
+            height_to_first_txinindex: StorableVec::import(&path.join("height_to_first_txinindex"), Version::from(1))?,
+            height_to_first_txoutindex: StorableVec::import(
+                &path.join("height_to_first_txoutindex"),
+                Version::from(1),
+            )?,
+            height_to_first_unknownindex: StorableVec::import(
+                &path.join("height_to_first_unkownindex"),
+                Version::from(1),
+            )?,
+            height_to_first_p2pk33index: StorableVec::import(
+                &path.join("height_to_first_p2pk33index"),
+                Version::from(1),
+            )?,
+            height_to_first_p2pk65index: StorableVec::import(
+                &path.join("height_to_first_p2pk65index"),
+                Version::from(1),
+            )?,
+            height_to_first_p2pkhindex: StorableVec::import(
+                &path.join("height_to_first_p2pkhindex"),
+                Version::from(1),
+            )?,
+            height_to_first_p2shindex: StorableVec::import(&path.join("height_to_first_p2shindex"), Version::from(1))?,
+            height_to_first_p2trindex: StorableVec::import(&path.join("height_to_first_p2trindex"), Version::from(1))?,
+            height_to_first_p2wpkhindex: StorableVec::import(
+                &path.join("height_to_first_p2wpkhindex"),
+                Version::from(1),
+            )?,
+            height_to_first_p2wshindex: StorableVec::import(
+                &path.join("height_to_first_p2wshindex"),
+                Version::from(1),
+            )?,
+            height_to_size: StorableVec::import(&path.join("height_to_size"), Version::from(1))?,
+            height_to_timestamp: StorableVec::import(&path.join("height_to_timestamp"), Version::from(1))?,
+            height_to_weight: StorableVec::import(&path.join("height_to_weight"), Version::from(1))?,
+            p2pk33index_to_p2pk33addressbytes: StorableVec::import(
+                &path.join("p2pk33index_to_p2pk33addressbytes"),
+                Version::from(1),
+            )?,
+            p2pk65index_to_p2pk65addressbytes: StorableVec::import(
+                &path.join("p2pk65index_to_p2pk65addressbytes"),
+                Version::from(1),
+            )?,
+            p2pkhindex_to_p2pkhaddressbytes: StorableVec::import(
+                &path.join("p2pkhindex_to_p2pkhaddressbytes"),
+                Version::from(1),
+            )?,
+            p2shindex_to_p2shaddressbytes: StorableVec::import(
+                &path.join("p2shindex_to_p2shaddressbytes"),
+                Version::from(1),
+            )?,
+            p2trindex_to_p2traddressbytes: StorableVec::import(
+                &path.join("p2trindex_to_p2traddressbytes"),
+                Version::from(1),
+            )?,
+            p2wpkhindex_to_p2wpkhaddressbytes: StorableVec::import(
+                &path.join("p2wpkhindex_to_p2wpkhaddressbytes"),
+                Version::from(1),
+            )?,
+            p2wshindex_to_p2wshaddressbytes: StorableVec::import(
+                &path.join("p2wshindex_to_p2wshaddressbytes"),
+                Version::from(1),
+            )?,
+            txindex_to_first_txinindex: StorableVec::import(
+                &path.join("txindex_to_first_txinindex"),
+                Version::from(1),
+            )?,
+            txindex_to_first_txoutindex: StorableVec::import(
+                &path.join("txindex_to_first_txoutindex"),
+                Version::from(1),
+            )?,
+            txindex_to_height: StorableVec::import(&path.join("txindex_to_height"), Version::from(1))?,
+            txindex_to_locktime: StorableVec::import(&path.join("txindex_to_locktime"), Version::from(1))?,
+            txindex_to_txid: StorableVec::import(&path.join("txindex_to_txid"), Version::from(1))?,
+            txindex_to_base_size: StorableVec::import(&path.join("txindex_to_base_size"), Version::from(1))?,
+            txindex_to_total_size: StorableVec::import(&path.join("txindex_to_total_size"), Version::from(1))?,
+            txindex_to_is_explicitly_rbf: StorableVec::import(
+                &path.join("txindex_to_is_explicitly_rbf"),
+                Version::from(1),
+            )?,
+            txindex_to_txversion: StorableVec::import(&path.join("txindex_to_txversion"), Version::from(1))?,
+            txinindex_to_txoutindex: StorableVec::import(&path.join("txinindex_to_txoutindex"), Version::from(1))?,
+            txoutindex_to_addressindex: StorableVec::import(
+                &path.join("txoutindex_to_addressindex"),
+                Version::from(1),
+            )?,
+            txoutindex_to_value: StorableVec::import(&path.join("txoutindex_to_value"), Version::from(1))?,
+        })
+    }
+
+    pub fn rollback(&mut self, starting_indexes: &Indexes) -> storable_vec::Result<()> {
+        let saved_height = starting_indexes.height.decremented();
+
+        // We don't want to override the starting indexes so we cut from n + 1
+        let height = starting_indexes.height.incremented();
+
+        self.height_to_first_addressindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_emptyindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_multisigindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_opreturnindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2pk33index
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2pk65index
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2pkhindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2shindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2trindex
+            .truncate_if_needed(height, saved_height)?;
+        self.height_to_first_p2wpkhindex
+            .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)?;
+
+        // Now we can cut everything that's out of date
+        let &Indexes {
+            addressindex,
+            height,
+            p2pk33index,
+            p2pk65index,
+            p2pkhindex,
+            p2shindex,
+            p2trindex,
+            p2wpkhindex,
+            p2wshindex,
+            txindex,
+            txinindex,
+            txoutindex,
+            ..
+        } = starting_indexes;
+
+        self.height_to_blockhash.truncate_if_needed(height, saved_height)?;
+        self.height_to_difficulty.truncate_if_needed(height, saved_height)?;
+        self.height_to_size.truncate_if_needed(height, saved_height)?;
+        self.height_to_timestamp.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
+            .truncate_if_needed(p2pk33index, saved_height)?;
+        self.p2pk65index_to_p2pk65addressbytes
+            .truncate_if_needed(p2pk65index, saved_height)?;
+        self.p2pkhindex_to_p2pkhaddressbytes
+            .truncate_if_needed(p2pkhindex, saved_height)?;
+        self.p2shindex_to_p2shaddressbytes
+            .truncate_if_needed(p2shindex, saved_height)?;
+        self.p2trindex_to_p2traddressbytes
+            .truncate_if_needed(p2trindex, saved_height)?;
+        self.p2wpkhindex_to_p2wpkhaddressbytes
+            .truncate_if_needed(p2wpkhindex, saved_height)?;
+        self.p2wshindex_to_p2wshaddressbytes
+            .truncate_if_needed(p2wshindex, saved_height)?;
+
+        self.txindex_to_first_txinindex
+            .truncate_if_needed(txindex, saved_height)?;
+        self.txindex_to_first_txoutindex
+            .truncate_if_needed(txindex, saved_height)?;
+        self.txindex_to_height.truncate_if_needed(txindex, saved_height)?;
+        self.txindex_to_locktime.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)?;
+
+        Ok(())
+    }
+
+    pub fn flush(&mut self, height: Height) -> io::Result<()> {
+        self.as_mut_any_vec_slice()
+            .into_par_iter()
+            .try_for_each(|vec| vec.flush(height))
+    }
+
+    pub fn starting_height(&mut self) -> Height {
+        self.as_mut_any_vec_slice()
+            .into_iter()
+            .map(|vec| vec.height().map(Height::incremented).unwrap_or_default())
+            .min()
+            .unwrap()
+    }
+
+    pub fn as_any_json_vec_slice(&self) -> [&dyn AnyJsonStorableVec; 43] {
+        [
+            &*self.addressindex_to_addresstype as &dyn AnyJsonStorableVec,
+            &*self.addressindex_to_addresstypeindex,
+            &*self.addressindex_to_height,
+            &*self.height_to_blockhash,
+            &*self.height_to_difficulty,
+            &*self.height_to_first_addressindex,
+            &*self.height_to_first_emptyindex,
+            &*self.height_to_first_multisigindex,
+            &*self.height_to_first_opreturnindex,
+            &*self.height_to_first_pushonlyindex,
+            &*self.height_to_first_txindex,
+            &*self.height_to_first_txinindex,
+            &*self.height_to_first_txoutindex,
+            &*self.height_to_first_unknownindex,
+            &*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_size,
+            &*self.height_to_timestamp,
+            &*self.height_to_weight,
+            &*self.p2pk33index_to_p2pk33addressbytes,
+            &*self.p2pk65index_to_p2pk65addressbytes,
+            &*self.p2pkhindex_to_p2pkhaddressbytes,
+            &*self.p2shindex_to_p2shaddressbytes,
+            &*self.p2trindex_to_p2traddressbytes,
+            &*self.p2wpkhindex_to_p2wpkhaddressbytes,
+            &*self.p2wshindex_to_p2wshaddressbytes,
+            &*self.txindex_to_first_txinindex,
+            &*self.txindex_to_first_txoutindex,
+            &*self.txindex_to_height,
+            &*self.txindex_to_locktime,
+            &*self.txindex_to_txid,
+            &*self.txindex_to_base_size,
+            &*self.txindex_to_total_size,
+            &*self.txindex_to_is_explicitly_rbf,
+            &*self.txindex_to_txversion,
+            &*self.txinindex_to_txoutindex,
+            &*self.txoutindex_to_addressindex,
+            &*self.txoutindex_to_value,
+        ]
+    }
+
+    pub fn as_mut_any_vec_slice(&mut self) -> [&mut dyn AnyStorableVec; 43] {
+        [
+            &mut self.addressindex_to_addresstype as &mut dyn AnyStorableVec,
+            &mut self.addressindex_to_addresstypeindex,
+            &mut self.addressindex_to_height,
+            &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_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_p2pk33index,
+            &mut self.height_to_first_p2pk65index,
+            &mut self.height_to_first_p2pkhindex,
+            &mut self.height_to_first_p2shindex,
+            &mut self.height_to_first_p2trindex,
+            &mut self.height_to_first_p2wpkhindex,
+            &mut self.height_to_first_p2wshindex,
+            &mut self.height_to_size,
+            &mut self.height_to_timestamp,
+            &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.txindex_to_base_size,
+            &mut self.txindex_to_total_size,
+            &mut self.txindex_to_is_explicitly_rbf,
+            &mut self.txindex_to_txversion,
+            &mut self.txinindex_to_txoutindex,
+            &mut self.txoutindex_to_addressindex,
+            &mut self.txoutindex_to_value,
+        ]
+    }
+}
+
+impl StorableVecs<CACHED_GETS> {
+    pub fn get_addressbytes(
+        &self,
+        addresstype: Addresstype,
+        addresstypeindex: Addresstypeindex,
+    ) -> storable_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(
+        &mut self,
+        index: Addresstypeindex,
+        addressbytes: Addressbytes,
+    ) -> storable_vec::Result<()> {
+        match addressbytes {
+            Addressbytes::P2PK65(bytes) => self
+                .p2pk65index_to_p2pk65addressbytes
+                .push_if_needed(index.into(), bytes),
+            Addressbytes::P2PK33(bytes) => self
+                .p2pk33index_to_p2pk33addressbytes
+                .push_if_needed(index.into(), bytes),
+            Addressbytes::P2PKH(bytes) => self.p2pkhindex_to_p2pkhaddressbytes.push_if_needed(index.into(), bytes),
+            Addressbytes::P2SH(bytes) => self.p2shindex_to_p2shaddressbytes.push_if_needed(index.into(), bytes),
+            Addressbytes::P2WPKH(bytes) => self
+                .p2wpkhindex_to_p2wpkhaddressbytes
+                .push_if_needed(index.into(), bytes),
+            Addressbytes::P2WSH(bytes) => self.p2wshindex_to_p2wshaddressbytes.push_if_needed(index.into(), bytes),
+            Addressbytes::P2TR(bytes) => self.p2trindex_to_p2traddressbytes.push_if_needed(index.into(), bytes),
+        }
+    }
+}

crates/brk_indexer/src/structs/addressbytes.rs

@@ -0,0 +1,196 @@
+use brk_parser::bitcoin::ScriptBuf;
+use color_eyre::eyre::eyre;
+use derive_deref::{Deref, DerefMut};
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use super::Addresstype;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Addressbytes {
+    P2PK65(P2PK65AddressBytes),
+    P2PK33(P2PK33AddressBytes),
+    P2PKH(P2PKHAddressBytes),
+    P2SH(P2SHAddressBytes),
+    P2WPKH(P2WPKHAddressBytes),
+    P2WSH(P2WSHAddressBytes),
+    P2TR(P2TRAddressBytes),
+}
+
+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[..],
+        }
+    }
+}
+
+impl TryFrom<(&ScriptBuf, Addresstype)> for Addressbytes {
+    type Error = color_eyre::Report;
+    fn try_from(tuple: (&ScriptBuf, Addresstype)) -> Result<Self, Self::Error> {
+        let (script, addresstype) = tuple;
+
+        match addresstype {
+            Addresstype::P2PK65 => {
+                let bytes = script.as_bytes();
+                let bytes = match bytes.len() {
+                    67 => &bytes[1..66],
+                    _ => {
+                        dbg!(bytes);
+                        return Err(eyre!("Wrong len"));
+                    }
+                };
+                Ok(Self::P2PK65(P2PK65AddressBytes(U8x65::from(bytes))))
+            }
+            Addresstype::P2PK33 => {
+                let bytes = script.as_bytes();
+                let bytes = match bytes.len() {
+                    35 => &bytes[1..34],
+                    _ => {
+                        dbg!(bytes);
+                        return Err(eyre!("Wrong len"));
+                    }
+                };
+                Ok(Self::P2PK33(P2PK33AddressBytes(U8x33::from(bytes))))
+            }
+            Addresstype::P2PKH => {
+                let bytes = &script.as_bytes()[3..23];
+                Ok(Self::P2PKH(P2PKHAddressBytes(U8x20::from(bytes))))
+            }
+            Addresstype::P2SH => {
+                let bytes = &script.as_bytes()[2..22];
+                Ok(Self::P2SH(P2SHAddressBytes(U8x20::from(bytes))))
+            }
+            Addresstype::P2WPKH => {
+                let bytes = &script.as_bytes()[2..];
+                Ok(Self::P2WPKH(P2WPKHAddressBytes(U8x20::from(bytes))))
+            }
+            Addresstype::P2WSH => {
+                let bytes = &script.as_bytes()[2..];
+                Ok(Self::P2WSH(P2WSHAddressBytes(U8x32::from(bytes))))
+            }
+            Addresstype::P2TR => {
+                let bytes = &script.as_bytes()[2..];
+                Ok(Self::P2TR(P2TRAddressBytes(U8x32::from(bytes))))
+            }
+            Addresstype::Multisig => Err(eyre!("multisig address type")),
+            Addresstype::PushOnly => Err(eyre!("push_only address type")),
+            Addresstype::Unknown => Err(eyre!("unknown address type")),
+            Addresstype::Empty => Err(eyre!("empty address type")),
+            Addresstype::OpReturn => Err(eyre!("op_return address type")),
+        }
+    }
+}
+
+impl From<P2PK65AddressBytes> for Addressbytes {
+    fn from(value: P2PK65AddressBytes) -> Self {
+        Self::P2PK65(value)
+    }
+}
+impl From<P2PK33AddressBytes> for Addressbytes {
+    fn from(value: P2PK33AddressBytes) -> Self {
+        Self::P2PK33(value)
+    }
+}
+impl From<P2PKHAddressBytes> for Addressbytes {
+    fn from(value: P2PKHAddressBytes) -> Self {
+        Self::P2PKH(value)
+    }
+}
+impl From<P2SHAddressBytes> for Addressbytes {
+    fn from(value: P2SHAddressBytes) -> Self {
+        Self::P2SH(value)
+    }
+}
+impl From<P2WPKHAddressBytes> for Addressbytes {
+    fn from(value: P2WPKHAddressBytes) -> Self {
+        Self::P2WPKH(value)
+    }
+}
+impl From<P2WSHAddressBytes> for Addressbytes {
+    fn from(value: P2WSHAddressBytes) -> Self {
+        Self::P2WSH(value)
+    }
+}
+impl From<P2TRAddressBytes> for Addressbytes {
+    fn from(value: P2TRAddressBytes) -> Self {
+        Self::P2TR(value)
+    }
+}
+
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct P2PK65AddressBytes(U8x65);
+
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct P2PK33AddressBytes(U8x33);
+
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct P2PKHAddressBytes(U8x20);
+
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct P2SHAddressBytes(U8x20);
+
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct P2WPKHAddressBytes(U8x20);
+
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct P2WSHAddressBytes(U8x32);
+
+#[derive(Debug, Clone, Deref, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct P2TRAddressBytes(U8x32);
+
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct U8x20([u8; 20]);
+impl From<&[u8]> for U8x20 {
+    fn from(slice: &[u8]) -> Self {
+        let mut arr = [0; 20];
+        arr.copy_from_slice(slice);
+        Self(arr)
+    }
+}
+
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct U8x32([u8; 32]);
+impl From<&[u8]> for U8x32 {
+    fn from(slice: &[u8]) -> Self {
+        let mut arr = [0; 32];
+        arr.copy_from_slice(slice);
+        Self(arr)
+    }
+}
+
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct U8x33(#[serde(with = "serde_bytes")] [u8; 33]);
+impl From<&[u8]> for U8x33 {
+    fn from(slice: &[u8]) -> Self {
+        let mut arr = [0; 33];
+        arr.copy_from_slice(slice);
+        Self(arr)
+    }
+}
+
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct U8x64(#[serde(with = "serde_bytes")] [u8; 64]);
+impl From<&[u8]> for U8x64 {
+    fn from(slice: &[u8]) -> Self {
+        let mut arr = [0; 64];
+        arr.copy_from_slice(slice);
+        Self(arr)
+    }
+}
+
+#[derive(Debug, Clone, Deref, DerefMut, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct U8x65(#[serde(with = "serde_bytes")] [u8; 65]);
+impl From<&[u8]> for U8x65 {
+    fn from(slice: &[u8]) -> Self {
+        let mut arr = [0; 65];
+        arr.copy_from_slice(slice);
+        Self(arr)
+    }
+}

crates/brk_indexer/src/structs/addressindex.rs

@@ -0,0 +1,95 @@
+use std::ops::Add;
+
+use derive_deref::{Deref, DerefMut};
+use fjall::Slice;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct Addressindex(u32);
+
+impl Addressindex {
+    pub const BYTES: usize = size_of::<Self>();
+
+    pub fn decremented(self) -> Self {
+        Self(*self - 1)
+    }
+
+    pub fn increment(&mut self) {
+        self.0 += 1;
+    }
+
+    pub fn incremented(self) -> Self {
+        Self(*self + 1)
+    }
+}
+
+impl From<u32> for Addressindex {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<u64> for Addressindex {
+    fn from(value: u64) -> Self {
+        Self(value as u32)
+    }
+}
+impl From<Addressindex> for u64 {
+    fn from(value: Addressindex) -> Self {
+        value.0 as u64
+    }
+}
+
+impl From<usize> for Addressindex {
+    fn from(value: usize) -> Self {
+        Self(value as u32)
+    }
+}
+impl From<Addressindex> for usize {
+    fn from(value: Addressindex) -> Self {
+        value.0 as usize
+    }
+}
+
+impl TryFrom<Slice> for Addressindex {
+    type Error = storable_vec::Error;
+    fn try_from(value: Slice) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<Addressindex> for Slice {
+    fn from(value: Addressindex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+
+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 {
+    type Output = Self;
+    fn add(self, rhs: Addressindex) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}

crates/brk_indexer/src/structs/addresstype.rs

@@ -0,0 +1,59 @@
+use brk_parser::bitcoin::ScriptBuf;
+use serde::Serialize;
+use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+
+#[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,
+    Multisig = 251,
+    PushOnly = 252,
+    OpReturn = 253,
+    Empty = 254,
+    Unknown = 255,
+}
+
+impl From<&ScriptBuf> for Addresstype {
+    fn from(script: &ScriptBuf) -> Self {
+        if script.is_p2pk() {
+            let bytes = script.as_bytes();
+
+            match bytes.len() {
+                67 => Self::P2PK65,
+                35 => Self::P2PK33,
+                _ => {
+                    dbg!(bytes);
+                    unreachable!()
+                }
+            }
+        } else if script.is_p2pkh() {
+            Self::P2PKH
+        } else if script.is_p2sh() {
+            Self::P2SH
+        } else if script.is_p2wpkh() {
+            Self::P2WPKH
+        } else if script.is_p2wsh() {
+            Self::P2WSH
+        } else if script.is_p2tr() {
+            Self::P2TR
+        } 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_indexer/src/structs/addresstypeindex.rs

@@ -0,0 +1,566 @@
+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,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct Addresstypeindex(u32);
+
+impl Addresstypeindex {
+    pub fn decremented(self) -> Self {
+        Self(*self - 1)
+    }
+
+    pub fn increment(&mut self) {
+        self.0 += 1;
+    }
+
+    pub fn incremented(self) -> Self {
+        Self(*self + 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_indexer/src/structs/blockhash.rs

@@ -0,0 +1,31 @@
+use std::mem;
+
+use brk_parser::{
+    Height,
+    rpc::{Client, RpcApi},
+};
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct BlockHash([u8; 32]);
+
+impl From<bitcoin::BlockHash> for BlockHash {
+    fn from(value: bitcoin::BlockHash) -> Self {
+        unsafe { mem::transmute(value) }
+    }
+}
+
+impl From<BlockHash> for bitcoin::BlockHash {
+    fn from(value: BlockHash) -> Self {
+        unsafe { mem::transmute(value) }
+    }
+}
+
+impl TryFrom<(&Client, Height)> for BlockHash {
+    type Error = brk_parser::rpc::Error;
+    fn try_from((rpc, height): (&Client, Height)) -> Result<Self, Self::Error> {
+        Ok(Self::from(rpc.get_block_hash(u64::from(height))?))
+    }
+}

crates/brk_indexer/src/structs/compressed.rs

@@ -0,0 +1,100 @@
+use std::hash::Hasher;
+
+use derive_deref::Deref;
+use fjall::Slice;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+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<Slice> for AddressHash {
+    type Error = storable_vec::Error;
+    fn try_from(value: Slice) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<&AddressHash> for Slice {
+    fn from(value: &AddressHash) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+impl From<AddressHash> for Slice {
+    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(copy_first_8bytes(&value[..]).unwrap())
+    }
+}
+impl TryFrom<Slice> for BlockHashPrefix {
+    type Error = storable_vec::Error;
+    fn try_from(value: Slice) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<&BlockHashPrefix> for Slice {
+    fn from(value: &BlockHashPrefix) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+impl From<BlockHashPrefix> for Slice {
+    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(copy_first_8bytes(&value[..]).unwrap())
+    }
+}
+impl TryFrom<Slice> for TxidPrefix {
+    type Error = storable_vec::Error;
+    fn try_from(value: Slice) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<&TxidPrefix> for Slice {
+    fn from(value: &TxidPrefix) -> Self {
+        Self::new(value.as_bytes())
+    }
+}
+impl From<TxidPrefix> for Slice {
+    fn from(value: TxidPrefix) -> Self {
+        Self::from(&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_indexer/src/structs/indexes.rs

@@ -0,0 +1,114 @@
+use brk_parser::NUMBER_OF_UNSAFE_BLOCKS;
+use brk_parser::{Height, rpc::Client};
+use color_eyre::eyre::ContextCompat;
+use storable_vec::CACHED_GETS;
+
+use crate::storage::{Fjalls, StorableVecs};
+
+use super::{
+    Addressindex, BlockHash, Emptyindex, Multisigindex, Opreturnindex, P2PK33index, P2PK65index, P2PKHindex, P2SHindex,
+    P2TRindex, P2WPKHindex, P2WSHindex, Pushonlyindex, Txindex, Txinindex, Txoutindex, Unknownindex,
+};
+
+#[derive(Debug, Default)]
+pub struct Indexes {
+    pub addressindex: Addressindex,
+    pub emptyindex: Emptyindex,
+    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,
+}
+
+impl Indexes {
+    pub fn push_if_needed(&self, vecs: &mut StorableVecs<CACHED_GETS>) -> storable_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_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_p2pk33index
+            .push_if_needed(height, self.p2pk33index)?;
+        vecs.height_to_first_p2pk65index
+            .push_if_needed(height, self.p2pk65index)?;
+        vecs.height_to_first_p2pkhindex
+            .push_if_needed(height, self.p2pkhindex)?;
+        vecs.height_to_first_p2shindex.push_if_needed(height, self.p2shindex)?;
+        vecs.height_to_first_p2trindex.push_if_needed(height, self.p2trindex)?;
+        vecs.height_to_first_p2wpkhindex
+            .push_if_needed(height, self.p2wpkhindex)?;
+        vecs.height_to_first_p2wshindex
+            .push_if_needed(height, self.p2wshindex)?;
+        Ok(())
+    }
+
+    pub fn push_future_if_needed(&mut self, vecs: &mut StorableVecs<CACHED_GETS>) -> storable_vec::Result<()> {
+        self.height.increment();
+        self.push_if_needed(vecs)?;
+        self.height.decrement();
+        Ok(())
+    }
+}
+
+impl TryFrom<(&mut StorableVecs<CACHED_GETS>, &Fjalls, &Client)> for Indexes {
+    type Error = color_eyre::Report;
+    fn try_from((vecs, trees, rpc): (&mut StorableVecs<CACHED_GETS>, &Fjalls, &Client)) -> color_eyre::Result<Self> {
+        // Height at which we wanna start: min last saved + 1 or 0
+        let starting_height = vecs.starting_height().min(trees.starting_height());
+
+        // But we also need to check the chain and start earlier in case of a reorg
+        let height = (starting_height
+            .checked_sub(NUMBER_OF_UNSAFE_BLOCKS as u32)
+            .unwrap_or_default()..*starting_height) // ..= because of last saved + 1
+            .map(Height::from)
+            .find(|height| {
+                let rpc_blockhash = BlockHash::try_from((rpc, *height)).unwrap();
+                let saved_blockhash = vecs.height_to_blockhash.get(*height).unwrap().unwrap();
+                &rpc_blockhash != saved_blockhash.as_ref()
+            })
+            .unwrap_or(starting_height);
+
+        Ok(Self {
+            addressindex: *vecs.height_to_first_addressindex.get(height)?.context("")?,
+            emptyindex: *vecs.height_to_first_emptyindex.get(height)?.context("")?,
+            height,
+            multisigindex: *vecs.height_to_first_multisigindex.get(height)?.context("")?,
+            opreturnindex: *vecs.height_to_first_opreturnindex.get(height)?.context("")?,
+            p2pk33index: *vecs.height_to_first_p2pk33index.get(height)?.context("")?,
+            p2pk65index: *vecs.height_to_first_p2pk65index.get(height)?.context("")?,
+            p2pkhindex: *vecs.height_to_first_p2pkhindex.get(height)?.context("")?,
+            p2shindex: *vecs.height_to_first_p2shindex.get(height)?.context("")?,
+            p2trindex: *vecs.height_to_first_p2trindex.get(height)?.context("")?,
+            p2wpkhindex: *vecs.height_to_first_p2wpkhindex.get(height)?.context("")?,
+            p2wshindex: *vecs.height_to_first_p2wshindex.get(height)?.context("")?,
+            pushonlyindex: *vecs.height_to_first_pushonlyindex.get(height)?.context("")?,
+            txindex: *vecs.height_to_first_txindex.get(height)?.context("")?,
+            txinindex: *vecs.height_to_first_txinindex.get(height)?.context("")?,
+            txoutindex: *vecs.height_to_first_txoutindex.get(height)?.context("")?,
+            unknownindex: *vecs.height_to_first_unknownindex.get(height)?.context("")?,
+        })
+    }
+}

crates/brk_indexer/src/structs/locktime.rs

@@ -0,0 +1,30 @@
+use brk_parser::Height;
+use serde::Serialize;
+use zerocopy::{Immutable, IntoBytes, KnownLayout, TryFromBytes};
+
+use super::Timestamp;
+
+#[derive(Debug, Immutable, Clone, Copy, IntoBytes, KnownLayout, TryFromBytes, Serialize)]
+#[repr(C)]
+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_indexer/src/structs/mod.rs

@@ -0,0 +1,37 @@
+mod addressbytes;
+mod addressindex;
+mod addresstype;
+mod addresstypeindex;
+mod blockhash;
+mod compressed;
+mod indexes;
+mod locktime;
+mod sats;
+mod timestamp;
+mod txid;
+mod txindex;
+mod txinindex;
+mod txoutindex;
+mod txversion;
+mod vin;
+mod vout;
+mod weight;
+
+pub use addressbytes::*;
+pub use addressindex::*;
+pub use addresstype::*;
+pub use addresstypeindex::*;
+pub use blockhash::*;
+pub use compressed::*;
+pub use indexes::*;
+pub use locktime::*;
+pub use sats::*;
+pub use timestamp::*;
+pub use txid::*;
+pub use txindex::*;
+pub use txinindex::*;
+pub use txoutindex::*;
+pub use txversion::*;
+pub use vin::*;
+pub use vout::*;
+pub use weight::*;

crates/brk_indexer/src/structs/sats.rs

@@ -0,0 +1,107 @@
+use std::{
+    iter::Sum,
+    ops::{Add, AddAssign, Mul, Sub, SubAssign},
+};
+
+use brk_parser::{Height, bitcoin::Amount};
+use derive_deref::{Deref, DerefMut};
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct Sats(u64);
+
+impl Sats {
+    pub const ZERO: Self = Self(0);
+
+    pub fn is_zero(&self) -> bool {
+        *self == Self::ZERO
+    }
+}
+
+impl Add for Sats {
+    type Output = Sats;
+    fn add(self, rhs: Sats) -> Self::Output {
+        Sats::from(*self + *rhs)
+    }
+}
+
+impl AddAssign for Sats {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs;
+    }
+}
+
+impl Sub for Sats {
+    type Output = Sats;
+    fn sub(self, rhs: Sats) -> Self::Output {
+        Sats::from(*self - *rhs)
+    }
+}
+
+impl SubAssign for Sats {
+    fn sub_assign(&mut self, rhs: Self) {
+        *self = *self - rhs;
+    }
+}
+
+impl Mul<Sats> for Sats {
+    type Output = Sats;
+    fn mul(self, rhs: Sats) -> Self::Output {
+        Sats::from(*self * *rhs)
+    }
+}
+
+impl Mul<u64> for Sats {
+    type Output = Sats;
+    fn mul(self, rhs: u64) -> Self::Output {
+        Sats::from(*self * rhs)
+    }
+}
+
+impl Mul<Height> for Sats {
+    type Output = Sats;
+    fn mul(self, rhs: Height) -> Self::Output {
+        Sats::from(*self * *rhs as u64)
+    }
+}
+
+impl Sum for Sats {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        let sats: u64 = iter.map(|sats| *sats).sum();
+        Sats::from(sats)
+    }
+}
+
+impl From<u64> for Sats {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Amount> for Sats {
+    fn from(value: Amount) -> Self {
+        Self(value.to_sat())
+    }
+}
+impl From<Sats> for Amount {
+    fn from(value: Sats) -> Self {
+        Self::from_sat(value.0)
+    }
+}

crates/brk_indexer/src/structs/timestamp.rs

@@ -0,0 +1,32 @@
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(
+    Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize,
+)]
+pub struct Timestamp(u32);
+
+impl From<u32> for Timestamp {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Timestamp> for jiff::Timestamp {
+    fn from(value: Timestamp) -> Self {
+        jiff::Timestamp::from_second(*value as i64).unwrap()
+    }
+}
+
+impl From<bitcoin::locktime::absolute::Time> for Timestamp {
+    fn from(value: bitcoin::locktime::absolute::Time) -> Self {
+        Self(value.to_consensus_u32())
+    }
+}
+
+impl From<Timestamp> for bitcoin::locktime::absolute::Time {
+    fn from(value: Timestamp) -> Self {
+        bitcoin::locktime::absolute::Time::from_consensus(*value).unwrap()
+    }
+}

crates/brk_indexer/src/structs/txid.rs

@@ -0,0 +1,20 @@
+use std::mem;
+
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, PartialEq, Eq, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct Txid([u8; 32]);
+
+impl From<bitcoin::Txid> for Txid {
+    fn from(value: bitcoin::Txid) -> Self {
+        unsafe { mem::transmute(value) }
+    }
+}
+
+impl From<Txid> for bitcoin::Txid {
+    fn from(value: Txid) -> Self {
+        unsafe { mem::transmute(value) }
+    }
+}

crates/brk_indexer/src/structs/txindex.rs

@@ -0,0 +1,102 @@
+use std::ops::{Add, AddAssign, Sub};
+
+use derive_deref::{Deref, DerefMut};
+use fjall::Slice;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct Txindex(u32);
+
+impl Txindex {
+    pub fn incremented(self) -> Self {
+        Self(*self + 1)
+    }
+
+    pub fn decremented(self) -> Self {
+        Self(*self - 1)
+    }
+}
+
+impl Add<Txindex> for Txindex {
+    type Output = Self;
+    fn add(self, rhs: Txindex) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+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) {
+        self.0 += rhs.0
+    }
+}
+
+impl Sub<Txindex> for Txindex {
+    type Output = Txindex;
+    fn sub(self, rhs: Txindex) -> Self::Output {
+        Self::from(*self - *rhs)
+    }
+}
+
+impl From<u32> for Txindex {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<u64> for Txindex {
+    fn from(value: u64) -> Self {
+        Self(value as u32)
+    }
+}
+impl From<Txindex> for u64 {
+    fn from(value: Txindex) -> Self {
+        value.0 as u64
+    }
+}
+
+impl From<usize> for Txindex {
+    fn from(value: usize) -> Self {
+        Self(value as u32)
+    }
+}
+impl From<Txindex> for usize {
+    fn from(value: Txindex) -> Self {
+        value.0 as usize
+    }
+}
+
+impl TryFrom<Slice> for Txindex {
+    type Error = storable_vec::Error;
+    fn try_from(value: Slice) -> Result<Self, Self::Error> {
+        Ok(Self::read_from_bytes(&value)?)
+    }
+}
+impl From<Txindex> for Slice {
+    fn from(value: Txindex) -> Self {
+        Self::new(value.as_bytes())
+    }
+}

crates/brk_indexer/src/structs/txinindex.rs

@@ -0,0 +1,101 @@
+use std::ops::{Add, AddAssign, Sub};
+
+use derive_deref::{Deref, DerefMut};
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use super::Vin;
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct Txinindex(u64);
+
+impl Txinindex {
+    pub fn incremented(self) -> Self {
+        Self(*self + 1)
+    }
+
+    pub fn decremented(self) -> Self {
+        Self(*self - 1)
+    }
+}
+
+impl Add<Txinindex> for Txinindex {
+    type Output = Self;
+    fn add(self, rhs: Txinindex) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Add<Vin> for Txinindex {
+    type Output = Self;
+    fn add(self, rhs: Vin) -> Self::Output {
+        Self(self.0 + u64::from(rhs))
+    }
+}
+
+impl Add<usize> for Txinindex {
+    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) {
+        self.0 += rhs.0
+    }
+}
+
+impl Sub<Txinindex> for Txinindex {
+    type Output = Self;
+    fn sub(self, rhs: Txinindex) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl From<Txinindex> for u32 {
+    fn from(value: Txinindex) -> Self {
+        if value.0 > u32::MAX as u64 {
+            panic!()
+        }
+        value.0 as u32
+    }
+}
+
+impl From<u64> for Txinindex {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+impl From<Txinindex> for u64 {
+    fn from(value: Txinindex) -> Self {
+        value.0
+    }
+}
+
+impl From<usize> for Txinindex {
+    fn from(value: usize) -> Self {
+        Self(value as u64)
+    }
+}
+impl From<Txinindex> for usize {
+    fn from(value: Txinindex) -> Self {
+        value.0 as usize
+    }
+}

crates/brk_indexer/src/structs/txoutindex.rs

@@ -0,0 +1,107 @@
+use std::ops::{Add, AddAssign, Sub};
+
+use derive_deref::{Deref, DerefMut};
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use super::Vout;
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Clone,
+    Copy,
+    Deref,
+    DerefMut,
+    Default,
+    FromBytes,
+    Immutable,
+    IntoBytes,
+    KnownLayout,
+    Serialize,
+)]
+pub struct Txoutindex(u64);
+
+impl Txoutindex {
+    pub const COINBASE: Self = Self(u64::MAX);
+
+    pub fn incremented(self) -> Self {
+        Self(*self + 1)
+    }
+
+    pub fn decremented(self) -> Self {
+        Self(*self - 1)
+    }
+
+    pub fn is_coinbase(self) -> bool {
+        self == Self::COINBASE
+    }
+}
+
+impl Add<Txoutindex> for Txoutindex {
+    type Output = Self;
+    fn add(self, rhs: Txoutindex) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Add<Vout> for Txoutindex {
+    type Output = Self;
+    fn add(self, rhs: Vout) -> Self::Output {
+        Self(self.0 + u64::from(rhs))
+    }
+}
+
+impl Add<usize> for Txoutindex {
+    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) {
+        self.0 += rhs.0
+    }
+}
+
+impl Sub<Txoutindex> for Txoutindex {
+    type Output = Self;
+    fn sub(self, rhs: Txoutindex) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl From<Txoutindex> for u32 {
+    fn from(value: Txoutindex) -> Self {
+        if value.0 > u32::MAX as u64 {
+            panic!()
+        }
+        value.0 as u32
+    }
+}
+
+impl From<u64> for Txoutindex {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+impl From<Txoutindex> for u64 {
+    fn from(value: Txoutindex) -> Self {
+        value.0
+    }
+}
+
+impl From<usize> for Txoutindex {
+    fn from(value: usize) -> Self {
+        Self(value as u64)
+    }
+}
+impl From<Txoutindex> for usize {
+    fn from(value: Txoutindex) -> Self {
+        value.0 as usize
+    }
+}

crates/brk_indexer/src/structs/txversion.rs

@@ -0,0 +1,18 @@
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct TxVersion(i32);
+
+impl From<bitcoin::transaction::Version> for TxVersion {
+    fn from(value: bitcoin::transaction::Version) -> Self {
+        Self(value.0)
+    }
+}
+
+impl From<TxVersion> for bitcoin::transaction::Version {
+    fn from(value: TxVersion) -> Self {
+        Self(value.0)
+    }
+}

crates/brk_indexer/src/structs/vin.rs

@@ -0,0 +1,31 @@
+use derive_deref::Deref;
+
+#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Vin(u32);
+
+impl Vin {
+    pub const ZERO: Self = Vin(0);
+    pub const ONE: Self = Vin(1);
+
+    pub fn is_zero(&self) -> bool {
+        *self == Self::ZERO
+    }
+}
+
+impl From<u32> for Vin {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for Vin {
+    fn from(value: usize) -> Self {
+        Self(value as u32)
+    }
+}
+
+impl From<Vin> for u64 {
+    fn from(value: Vin) -> Self {
+        value.0 as u64
+    }
+}

crates/brk_indexer/src/structs/vout.rs

@@ -0,0 +1,30 @@
+use derive_deref::Deref;
+
+#[derive(Debug, Deref, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Vout(u32);
+
+impl Vout {
+    const ZERO: Self = Vout(0);
+
+    pub fn is_zero(&self) -> bool {
+        *self == Self::ZERO
+    }
+}
+
+impl From<u32> for Vout {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<usize> for Vout {
+    fn from(value: usize) -> Self {
+        Self(value as u32)
+    }
+}
+
+impl From<Vout> for u64 {
+    fn from(value: Vout) -> Self {
+        value.0 as u64
+    }
+}

crates/brk_indexer/src/structs/weight.rs

@@ -0,0 +1,18 @@
+use derive_deref::Deref;
+use serde::Serialize;
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+#[derive(Debug, Deref, Clone, Copy, Immutable, IntoBytes, KnownLayout, FromBytes, Serialize)]
+pub struct Weight(u64);
+
+impl From<bitcoin::Weight> for Weight {
+    fn from(value: bitcoin::Weight) -> Self {
+        Self(value.to_wu())
+    }
+}
+
+impl From<Weight> for bitcoin::Weight {
+    fn from(value: Weight) -> Self {
+        Self::from_wu(*value)
+    }
+}