global: MASSIVE snapshot

crates/brk_computer/src/transactions/compute.rs

@@ -0,0 +1,61 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use vecdb::Exit;
+
+use crate::{indexes, inputs, outputs, price, ComputeIndexes};
+
+use super::Vecs;
+
+impl Vecs {
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        inputs: &inputs::Vecs,
+        outputs: &outputs::Vecs,
+        starting_indexes: &ComputeIndexes,
+        price: Option<&price::Vecs>,
+        exit: &Exit,
+    ) -> Result<()> {
+        // Count computes first
+        self.count
+            .compute(indexer, indexes, starting_indexes, exit)?;
+
+        // Versions depends on count
+        self.versions
+            .compute(indexer, indexes, starting_indexes, exit)?;
+
+        // Size computes next
+        self.size
+            .compute(indexer, indexes, starting_indexes, exit)?;
+
+        // Fees depends on size
+        self.fees.compute(
+            indexer,
+            indexes,
+            inputs,
+            &self.size,
+            starting_indexes,
+            price,
+            exit,
+        )?;
+
+        // Volume depends on fees and input/output counts
+        self.volume.compute(
+            indexer,
+            indexes,
+            &self.count,
+            &self.fees,
+            &inputs.count,
+            &outputs.count,
+            starting_indexes,
+            price,
+            exit,
+        )?;
+
+        let _lock = exit.lock();
+        self.db.compact()?;
+        Ok(())
+    }
+}

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

@@ -0,0 +1,29 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use vecdb::Exit;
+
+use super::Vecs;
+use crate::{indexes, ComputeIndexes};
+
+impl Vecs {
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.indexes_to_tx_count
+            .compute_all(indexes, starting_indexes, exit, |v| {
+                v.compute_count_from_indexes(
+                    starting_indexes.height,
+                    &indexer.vecs.tx.height_to_first_txindex,
+                    &indexer.vecs.tx.txindex_to_txid,
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/transactions/count/import.rs

@@ -0,0 +1,55 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_types::{StoredBool, TxIndex, Version};
+use vecdb::{Database, IterableCloneableVec, LazyVecFrom2};
+
+use super::Vecs;
+use crate::{
+    indexes,
+    internal::{ComputedVecsFromHeight, Source, VecBuilderOptions},
+};
+
+impl Vecs {
+    pub fn forced_import(
+        db: &Database,
+        version: Version,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let v0 = Version::ZERO;
+
+        let full_stats = || {
+            VecBuilderOptions::default()
+                .add_average()
+                .add_minmax()
+                .add_percentiles()
+                .add_sum()
+                .add_cumulative()
+        };
+
+        let txindex_to_is_coinbase = LazyVecFrom2::init(
+            "is_coinbase",
+            version + v0,
+            indexer.vecs.tx.txindex_to_height.boxed_clone(),
+            indexer.vecs.tx.height_to_first_txindex.boxed_clone(),
+            |index: TxIndex, txindex_to_height_iter, height_to_first_txindex_iter| {
+                txindex_to_height_iter.get(index).map(|height| {
+                    let txindex = height_to_first_txindex_iter.get_unwrap(height);
+                    StoredBool::from(index == txindex)
+                })
+            },
+        );
+
+        Ok(Self {
+            indexes_to_tx_count: ComputedVecsFromHeight::forced_import(
+                db,
+                "tx_count",
+                Source::Compute,
+                version + v0,
+                indexes,
+                full_stats(),
+            )?,
+            txindex_to_is_coinbase,
+        })
+    }
+}

crates/brk_computer/src/transactions/count/mod.rs

@@ -0,0 +1,5 @@
+mod compute;
+mod import;
+mod vecs;
+
+pub use vecs::Vecs;

crates/brk_computer/src/transactions/count/vecs.rs

@@ -0,0 +1,11 @@
+use brk_traversable::Traversable;
+use brk_types::{Height, StoredBool, StoredU64, TxIndex};
+use vecdb::LazyVecFrom2;
+
+use crate::internal::ComputedVecsFromHeight;
+
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    pub indexes_to_tx_count: ComputedVecsFromHeight<StoredU64>,
+    pub txindex_to_is_coinbase: LazyVecFrom2<TxIndex, StoredBool, TxIndex, Height, Height, TxIndex>,
+}

crates/brk_computer/src/transactions/fees/compute.rs

@@ -0,0 +1,80 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_types::{FeeRate, Sats};
+use vecdb::{Exit, unlikely};
+
+use super::Vecs;
+use super::super::size;
+use crate::{indexes, inputs, price, ComputeIndexes};
+
+impl Vecs {
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        txins: &inputs::Vecs,
+        size_vecs: &size::Vecs,
+        starting_indexes: &ComputeIndexes,
+        price: Option<&price::Vecs>,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.txindex_to_input_value.compute_sum_from_indexes(
+            starting_indexes.txindex,
+            &indexer.vecs.tx.txindex_to_first_txinindex,
+            &indexes.transaction.txindex_to_input_count,
+            &txins.spent.txinindex_to_value,
+            exit,
+        )?;
+
+        self.txindex_to_output_value.compute_sum_from_indexes(
+            starting_indexes.txindex,
+            &indexer.vecs.tx.txindex_to_first_txoutindex,
+            &indexes.transaction.txindex_to_output_count,
+            &indexer.vecs.txout.txoutindex_to_value,
+            exit,
+        )?;
+
+        self.txindex_to_fee.compute_transform2(
+            starting_indexes.txindex,
+            &self.txindex_to_input_value,
+            &self.txindex_to_output_value,
+            |(i, input, output, ..)| {
+                let fee = if unlikely(input.is_max()) {
+                    Sats::ZERO
+                } else {
+                    input - output
+                };
+                (i, fee)
+            },
+            exit,
+        )?;
+
+        self.txindex_to_fee_rate.compute_transform2(
+            starting_indexes.txindex,
+            &self.txindex_to_fee,
+            &size_vecs.txindex_to_vsize,
+            |(txindex, fee, vsize, ..)| (txindex, FeeRate::from((fee, vsize))),
+            exit,
+        )?;
+
+        self.indexes_to_fee.compute_rest(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&self.txindex_to_fee),
+            price,
+        )?;
+
+        self.indexes_to_fee_rate.compute_rest(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&self.txindex_to_fee_rate),
+        )?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/transactions/fees/import.rs

@@ -0,0 +1,64 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_types::Version;
+use vecdb::{Database, EagerVec, ImportableVec, IterableCloneableVec};
+
+use super::Vecs;
+use crate::{
+    indexes, price,
+    internal::{ComputedValueVecsFromTxindex, ComputedVecsFromTxindex, Source, VecBuilderOptions},
+};
+
+impl Vecs {
+    pub fn forced_import(
+        db: &Database,
+        version: Version,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+    ) -> Result<Self> {
+        let v0 = Version::ZERO;
+
+        let stats = || {
+            VecBuilderOptions::default()
+                .add_average()
+                .add_minmax()
+                .add_percentiles()
+        };
+
+        let txindex_to_input_value = EagerVec::forced_import(db, "input_value", version + v0)?;
+        let txindex_to_output_value = EagerVec::forced_import(db, "output_value", version + v0)?;
+        let txindex_to_fee = EagerVec::forced_import(db, "fee", version + v0)?;
+        let txindex_to_fee_rate = EagerVec::forced_import(db, "fee_rate", version + v0)?;
+
+        Ok(Self {
+            txindex_to_input_value,
+            txindex_to_output_value,
+            txindex_to_fee: txindex_to_fee.clone(),
+            txindex_to_fee_rate: txindex_to_fee_rate.clone(),
+            indexes_to_fee: ComputedValueVecsFromTxindex::forced_import(
+                db,
+                "fee",
+                indexer,
+                indexes,
+                Source::Vec(txindex_to_fee.boxed_clone()),
+                version + v0,
+                price,
+                VecBuilderOptions::default()
+                    .add_sum()
+                    .add_cumulative()
+                    .add_percentiles()
+                    .add_minmax()
+                    .add_average(),
+            )?,
+            indexes_to_fee_rate: ComputedVecsFromTxindex::forced_import(
+                db,
+                "fee_rate",
+                Source::Vec(txindex_to_fee_rate.boxed_clone()),
+                version + v0,
+                indexes,
+                stats(),
+            )?,
+        })
+    }
+}

crates/brk_computer/src/transactions/fees/mod.rs

@@ -0,0 +1,5 @@
+mod compute;
+mod import;
+mod vecs;
+
+pub use vecs::Vecs;

crates/brk_computer/src/transactions/fees/vecs.rs

@@ -0,0 +1,15 @@
+use brk_traversable::Traversable;
+use brk_types::{FeeRate, Sats, TxIndex};
+use vecdb::{EagerVec, PcoVec};
+
+use crate::internal::{ComputedValueVecsFromTxindex, ComputedVecsFromTxindex};
+
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    pub txindex_to_input_value: EagerVec<PcoVec<TxIndex, Sats>>,
+    pub txindex_to_output_value: EagerVec<PcoVec<TxIndex, Sats>>,
+    pub txindex_to_fee: EagerVec<PcoVec<TxIndex, Sats>>,
+    pub txindex_to_fee_rate: EagerVec<PcoVec<TxIndex, FeeRate>>,
+    pub indexes_to_fee: ComputedValueVecsFromTxindex,
+    pub indexes_to_fee_rate: ComputedVecsFromTxindex<FeeRate>,
+}

crates/brk_computer/src/transactions/import.rs

@@ -0,0 +1,51 @@
+use std::path::Path;
+
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_traversable::Traversable;
+use brk_types::Version;
+use vecdb::{Database, PAGE_SIZE};
+
+use crate::{indexes, price};
+
+use super::{CountVecs, FeesVecs, SizeVecs, Vecs, VersionsVecs, VolumeVecs};
+
+impl Vecs {
+    pub fn forced_import(
+        parent_path: &Path,
+        parent_version: Version,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        price: Option<&price::Vecs>,
+    ) -> Result<Self> {
+        let db = Database::open(&parent_path.join(super::DB_NAME))?;
+        db.set_min_len(PAGE_SIZE * 50_000_000)?;
+
+        let version = parent_version + Version::ZERO;
+        let compute_dollars = price.is_some();
+
+        let count = CountVecs::forced_import(&db, version, indexer, indexes)?;
+        let size = SizeVecs::forced_import(&db, version, indexer, indexes)?;
+        let fees = FeesVecs::forced_import(&db, version, indexer, indexes, price)?;
+        let versions = VersionsVecs::forced_import(&db, version, indexes)?;
+        let volume = VolumeVecs::forced_import(&db, version, indexes, compute_dollars)?;
+
+        let this = Self {
+            db,
+            count,
+            size,
+            fees,
+            versions,
+            volume,
+        };
+
+        this.db.retain_regions(
+            this.iter_any_exportable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
+        this.db.compact()?;
+
+        Ok(this)
+    }
+}

crates/brk_computer/src/transactions/mod.rs

@@ -0,0 +1,31 @@
+pub mod count;
+pub mod fees;
+pub mod size;
+pub mod versions;
+pub mod volume;
+
+mod compute;
+mod import;
+
+use brk_traversable::Traversable;
+use vecdb::Database;
+
+pub use count::Vecs as CountVecs;
+pub use fees::Vecs as FeesVecs;
+pub use size::Vecs as SizeVecs;
+pub use versions::Vecs as VersionsVecs;
+pub use volume::Vecs as VolumeVecs;
+
+pub const DB_NAME: &str = "transactions";
+
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    #[traversable(skip)]
+    pub(crate) db: Database,
+
+    pub count: CountVecs,
+    pub size: SizeVecs,
+    pub fees: FeesVecs,
+    pub versions: VersionsVecs,
+    pub volume: VolumeVecs,
+}

crates/brk_computer/src/transactions/size/compute.rs

@@ -0,0 +1,34 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use vecdb::Exit;
+
+use super::Vecs;
+use crate::{indexes, ComputeIndexes};
+
+impl Vecs {
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.indexes_to_tx_weight.compute_rest(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&self.txindex_to_weight),
+        )?;
+
+        self.indexes_to_tx_vsize.compute_rest(
+            indexer,
+            indexes,
+            starting_indexes,
+            exit,
+            Some(&self.txindex_to_vsize),
+        )?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/transactions/size/import.rs

@@ -0,0 +1,78 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_types::{TxIndex, VSize, Version, Weight};
+use vecdb::{Database, IterableCloneableVec, LazyVecFrom2, VecIndex};
+
+use super::Vecs;
+use crate::{
+    indexes,
+    internal::{ComputedVecsFromTxindex, Source, VecBuilderOptions},
+};
+
+impl Vecs {
+    pub fn forced_import(
+        db: &Database,
+        version: Version,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let v0 = Version::ZERO;
+
+        let stats = || {
+            VecBuilderOptions::default()
+                .add_average()
+                .add_minmax()
+                .add_percentiles()
+        };
+
+        let txindex_to_weight = LazyVecFrom2::init(
+            "weight",
+            version + v0,
+            indexer.vecs.tx.txindex_to_base_size.boxed_clone(),
+            indexer.vecs.tx.txindex_to_total_size.boxed_clone(),
+            |index: TxIndex, txindex_to_base_size_iter, txindex_to_total_size_iter| {
+                let index = index.to_usize();
+                txindex_to_base_size_iter.get_at(index).map(|base_size| {
+                    let total_size = txindex_to_total_size_iter.get_at_unwrap(index);
+                    Weight::from_sizes(*base_size, *total_size)
+                })
+            },
+        );
+
+        // Derive directly from eager sources to avoid Lazy <- Lazy
+        let txindex_to_vsize = LazyVecFrom2::init(
+            "vsize",
+            version + v0,
+            indexer.vecs.tx.txindex_to_base_size.boxed_clone(),
+            indexer.vecs.tx.txindex_to_total_size.boxed_clone(),
+            |index: TxIndex, txindex_to_base_size_iter, txindex_to_total_size_iter| {
+                let index = index.to_usize();
+                txindex_to_base_size_iter.get_at(index).map(|base_size| {
+                    let total_size = txindex_to_total_size_iter.get_at_unwrap(index);
+                    VSize::from(Weight::from_sizes(*base_size, *total_size))
+                })
+            },
+        );
+
+        Ok(Self {
+            indexes_to_tx_vsize: ComputedVecsFromTxindex::forced_import(
+                db,
+                "tx_vsize",
+                Source::Vec(txindex_to_vsize.boxed_clone()),
+                version + v0,
+                indexes,
+                stats(),
+            )?,
+            indexes_to_tx_weight: ComputedVecsFromTxindex::forced_import(
+                db,
+                "tx_weight",
+                Source::Vec(txindex_to_weight.boxed_clone()),
+                version + v0,
+                indexes,
+                stats(),
+            )?,
+            txindex_to_vsize,
+            txindex_to_weight,
+        })
+    }
+}

crates/brk_computer/src/transactions/size/mod.rs

@@ -0,0 +1,5 @@
+mod compute;
+mod import;
+mod vecs;
+
+pub use vecs::Vecs;

crates/brk_computer/src/transactions/size/vecs.rs

@@ -0,0 +1,14 @@
+use brk_traversable::Traversable;
+use brk_types::{StoredU32, TxIndex, VSize, Weight};
+use vecdb::LazyVecFrom2;
+
+use crate::internal::ComputedVecsFromTxindex;
+
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    pub indexes_to_tx_vsize: ComputedVecsFromTxindex<VSize>,
+    pub indexes_to_tx_weight: ComputedVecsFromTxindex<Weight>,
+    // Both derive directly from eager sources (base_size, total_size) to avoid Lazy <- Lazy
+    pub txindex_to_vsize: LazyVecFrom2<TxIndex, VSize, TxIndex, StoredU32, TxIndex, StoredU32>,
+    pub txindex_to_weight: LazyVecFrom2<TxIndex, Weight, TxIndex, StoredU32, TxIndex, StoredU32>,
+}

crates/brk_computer/src/transactions/versions/compute.rs

@@ -0,0 +1,40 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_types::{StoredU64, TxVersion};
+use vecdb::{Exit, TypedVecIterator};
+
+use super::Vecs;
+use crate::{indexes, internal::ComputedVecsFromHeight, ComputeIndexes};
+
+impl Vecs {
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        let compute_indexes_to_tx_vany =
+            |indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredU64>, txversion: TxVersion| {
+                let mut txindex_to_txversion_iter = indexer.vecs.tx.txindex_to_txversion.iter()?;
+                indexes_to_tx_vany.compute_all(indexes, starting_indexes, exit, |vec| {
+                    vec.compute_filtered_count_from_indexes(
+                        starting_indexes.height,
+                        &indexer.vecs.tx.height_to_first_txindex,
+                        &indexer.vecs.tx.txindex_to_txid,
+                        |txindex| {
+                            let v = txindex_to_txversion_iter.get_unwrap(txindex);
+                            v == txversion
+                        },
+                        exit,
+                    )?;
+                    Ok(())
+                })
+            };
+        compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v1, TxVersion::ONE)?;
+        compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v2, TxVersion::TWO)?;
+        compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v3, TxVersion::THREE)?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/transactions/versions/import.rs

@@ -0,0 +1,47 @@
+use brk_error::Result;
+use brk_types::Version;
+use vecdb::Database;
+
+use super::Vecs;
+use crate::{
+    indexes,
+    internal::{ComputedVecsFromHeight, Source, VecBuilderOptions},
+};
+
+impl Vecs {
+    pub fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let v0 = Version::ZERO;
+        let sum_cum = || VecBuilderOptions::default().add_sum().add_cumulative();
+
+        Ok(Self {
+            indexes_to_tx_v1: ComputedVecsFromHeight::forced_import(
+                db,
+                "tx_v1",
+                Source::Compute,
+                version + v0,
+                indexes,
+                sum_cum(),
+            )?,
+            indexes_to_tx_v2: ComputedVecsFromHeight::forced_import(
+                db,
+                "tx_v2",
+                Source::Compute,
+                version + v0,
+                indexes,
+                sum_cum(),
+            )?,
+            indexes_to_tx_v3: ComputedVecsFromHeight::forced_import(
+                db,
+                "tx_v3",
+                Source::Compute,
+                version + v0,
+                indexes,
+                sum_cum(),
+            )?,
+        })
+    }
+}

crates/brk_computer/src/transactions/versions/mod.rs

@@ -0,0 +1,5 @@
+mod compute;
+mod import;
+mod vecs;
+
+pub use vecs::Vecs;

crates/brk_computer/src/transactions/versions/vecs.rs

@@ -0,0 +1,11 @@
+use brk_traversable::Traversable;
+use brk_types::StoredU64;
+
+use crate::internal::ComputedVecsFromHeight;
+
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    pub indexes_to_tx_v1: ComputedVecsFromHeight<StoredU64>,
+    pub indexes_to_tx_v2: ComputedVecsFromHeight<StoredU64>,
+    pub indexes_to_tx_v3: ComputedVecsFromHeight<StoredU64>,
+}

crates/brk_computer/src/transactions/volume/compute.rs

@@ -0,0 +1,134 @@
+use brk_error::Result;
+use brk_indexer::Indexer;
+use brk_types::{StoredF32, ONE_DAY_IN_SEC_F64};
+use vecdb::Exit;
+
+use super::Vecs;
+use super::super::{count, fees};
+use crate::{indexes, inputs, outputs, price, ComputeIndexes};
+
+impl Vecs {
+    #[allow(clippy::too_many_arguments)]
+    pub fn compute(
+        &mut self,
+        indexer: &Indexer,
+        indexes: &indexes::Vecs,
+        count_vecs: &count::Vecs,
+        fees_vecs: &fees::Vecs,
+        inputs_count: &inputs::CountVecs,
+        outputs_count: &outputs::CountVecs,
+        starting_indexes: &ComputeIndexes,
+        price: Option<&price::Vecs>,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.indexes_to_sent_sum
+            .compute_all(indexes, price, starting_indexes, exit, |v| {
+                v.compute_filtered_sum_from_indexes(
+                    starting_indexes.height,
+                    &indexer.vecs.tx.height_to_first_txindex,
+                    &indexes.block.height_to_txindex_count,
+                    &fees_vecs.txindex_to_input_value,
+                    |sats| !sats.is_max(),
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_annualized_volume
+            .compute_all(starting_indexes, exit, |v| {
+                v.compute_sum(
+                    starting_indexes.dateindex,
+                    self.indexes_to_sent_sum.sats.dateindex.unwrap_sum(),
+                    365,
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_annualized_volume_btc
+            .compute_all(starting_indexes, exit, |v| {
+                v.compute_sum(
+                    starting_indexes.dateindex,
+                    self.indexes_to_sent_sum.bitcoin.dateindex.unwrap_sum(),
+                    365,
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        if let Some(indexes_to_sent_sum) = self.indexes_to_sent_sum.dollars.as_ref() {
+            self.indexes_to_annualized_volume_usd
+                .compute_all(starting_indexes, exit, |v| {
+                    v.compute_sum(
+                        starting_indexes.dateindex,
+                        indexes_to_sent_sum.dateindex.unwrap_sum(),
+                        365,
+                        exit,
+                    )?;
+                    Ok(())
+                })?;
+        }
+
+        self.indexes_to_tx_per_sec
+            .compute_all(starting_indexes, exit, |v| {
+                v.compute_transform2(
+                    starting_indexes.dateindex,
+                    count_vecs.indexes_to_tx_count.dateindex.unwrap_sum(),
+                    &indexes.time.dateindex_to_date,
+                    |(i, tx_count, date, ..)| {
+                        let completion = date.completion();
+                        let per_sec = if completion == 0.0 {
+                            StoredF32::NAN
+                        } else {
+                            StoredF32::from(*tx_count as f64 / (completion * ONE_DAY_IN_SEC_F64))
+                        };
+                        (i, per_sec)
+                    },
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_inputs_per_sec
+            .compute_all(starting_indexes, exit, |v| {
+                v.compute_transform2(
+                    starting_indexes.dateindex,
+                    inputs_count.indexes_to_count.dateindex.unwrap_sum(),
+                    &indexes.time.dateindex_to_date,
+                    |(i, input_count, date, ..)| {
+                        let completion = date.completion();
+                        let per_sec = if completion == 0.0 {
+                            StoredF32::NAN
+                        } else {
+                            StoredF32::from(*input_count as f64 / (completion * ONE_DAY_IN_SEC_F64))
+                        };
+                        (i, per_sec)
+                    },
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_outputs_per_sec
+            .compute_all(starting_indexes, exit, |v| {
+                v.compute_transform2(
+                    starting_indexes.dateindex,
+                    outputs_count.indexes_to_count.dateindex.unwrap_sum(),
+                    &indexes.time.dateindex_to_date,
+                    |(i, output_count, date, ..)| {
+                        let completion = date.completion();
+                        let per_sec = if completion == 0.0 {
+                            StoredF32::NAN
+                        } else {
+                            StoredF32::from(*output_count as f64 / (completion * ONE_DAY_IN_SEC_F64))
+                        };
+                        (i, per_sec)
+                    },
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/transactions/volume/import.rs

@@ -0,0 +1,82 @@
+use brk_error::Result;
+use brk_types::Version;
+use vecdb::Database;
+
+use super::Vecs;
+use crate::{
+    internal::{ComputedValueVecsFromHeight, ComputedVecsFromDateIndex, Source, VecBuilderOptions},
+    indexes,
+};
+
+impl Vecs {
+    pub fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+        compute_dollars: bool,
+    ) -> Result<Self> {
+        let v0 = Version::ZERO;
+        let v2 = Version::TWO;
+        let last = || VecBuilderOptions::default().add_last();
+
+        Ok(Self {
+            indexes_to_sent_sum: ComputedValueVecsFromHeight::forced_import(
+                db,
+                "sent_sum",
+                Source::Compute,
+                version + v0,
+                VecBuilderOptions::default().add_sum(),
+                compute_dollars,
+                indexes,
+            )?,
+            indexes_to_annualized_volume: ComputedVecsFromDateIndex::forced_import(
+                db,
+                "annualized_volume",
+                Source::Compute,
+                version + v0,
+                indexes,
+                last(),
+            )?,
+            indexes_to_annualized_volume_btc: ComputedVecsFromDateIndex::forced_import(
+                db,
+                "annualized_volume_btc",
+                Source::Compute,
+                version + v0,
+                indexes,
+                last(),
+            )?,
+            indexes_to_annualized_volume_usd: ComputedVecsFromDateIndex::forced_import(
+                db,
+                "annualized_volume_usd",
+                Source::Compute,
+                version + v0,
+                indexes,
+                last(),
+            )?,
+            indexes_to_tx_per_sec: ComputedVecsFromDateIndex::forced_import(
+                db,
+                "tx_per_sec",
+                Source::Compute,
+                version + v2,
+                indexes,
+                last(),
+            )?,
+            indexes_to_outputs_per_sec: ComputedVecsFromDateIndex::forced_import(
+                db,
+                "outputs_per_sec",
+                Source::Compute,
+                version + v2,
+                indexes,
+                last(),
+            )?,
+            indexes_to_inputs_per_sec: ComputedVecsFromDateIndex::forced_import(
+                db,
+                "inputs_per_sec",
+                Source::Compute,
+                version + v2,
+                indexes,
+                last(),
+            )?,
+        })
+    }
+}

crates/brk_computer/src/transactions/volume/mod.rs

@@ -0,0 +1,5 @@
+mod compute;
+mod import;
+mod vecs;
+
+pub use vecs::Vecs;

crates/brk_computer/src/transactions/volume/vecs.rs

@@ -0,0 +1,16 @@
+use brk_traversable::Traversable;
+use brk_types::{Bitcoin, Dollars, Sats, StoredF32};
+
+use crate::internal::{ComputedValueVecsFromHeight, ComputedVecsFromDateIndex};
+
+/// Volume metrics
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    pub indexes_to_sent_sum: ComputedValueVecsFromHeight,
+    pub indexes_to_annualized_volume: ComputedVecsFromDateIndex<Sats>,
+    pub indexes_to_annualized_volume_btc: ComputedVecsFromDateIndex<Bitcoin>,
+    pub indexes_to_annualized_volume_usd: ComputedVecsFromDateIndex<Dollars>,
+    pub indexes_to_tx_per_sec: ComputedVecsFromDateIndex<StoredF32>,
+    pub indexes_to_outputs_per_sec: ComputedVecsFromDateIndex<StoredF32>,
+    pub indexes_to_inputs_per_sec: ComputedVecsFromDateIndex<StoredF32>,
+}