global: adding support for safe lengths

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

@@ -1,27 +1,24 @@
 use brk_error::{OptionData, Result};
 use brk_indexer::Indexer;
-use brk_types::{Indexes, StoredU64};
+use brk_types::StoredU64;
 use vecdb::{AnyVec, Exit, ReadableVec, VecIndex, WritableVec};
 
 use super::{Vecs, WithInputTypes};
 use crate::internal::{CoinbasePolicy, PerBlockCumulativeRolling, walk_blocks};
 
 impl Vecs {
-    pub(crate) fn compute(
-        &mut self,
-        indexer: &Indexer,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-    ) -> Result<()> {
+    pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
+        let starting_lengths = indexer.safe_lengths();
+
         let dep_version = indexer.vecs.inputs.output_type.version()
             + indexer.vecs.transactions.first_tx_index.version()
             + indexer.vecs.transactions.first_txin_index.version()
             + indexer.vecs.transactions.txid.version();
 
         self.input_count
-            .validate_and_truncate(dep_version, starting_indexes.height)?;
+            .validate_and_truncate(dep_version, starting_lengths.height)?;
         self.tx_count
-            .validate_and_truncate(dep_version, starting_indexes.height)?;
+            .validate_and_truncate(dep_version, starting_lengths.height)?;
 
         let skip = self
             .input_count
@@ -84,15 +81,15 @@ impl Vecs {
             }
 
             self.input_count
-                .compute_rest(starting_indexes.height, exit)?;
-            self.tx_count.compute_rest(starting_indexes.height, exit)?;
+                .compute_rest(starting_lengths.height, exit)?;
+            self.tx_count.compute_rest(starting_lengths.height, exit)?;
         }
 
         for (otype, source) in self.input_count.by_type.iter_typed() {
             self.input_share.get_mut(otype).compute_count_ratio(
                 source,
                 &self.input_count.all,
-                starting_indexes.height,
+                starting_lengths.height,
                 exit,
             )?;
         }
@@ -101,7 +98,7 @@ impl Vecs {
             self.tx_share.get_mut(otype).compute_count_ratio(
                 source,
                 &self.tx_count.all,
-                starting_indexes.height,
+                starting_lengths.height,
                 exit,
             )?;
         }

crates/brk_computer/src/inputs/compute.rs

@@ -1,6 +1,5 @@
 use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_types::Indexes;
 use vecdb::Exit;
 
 use super::Vecs;
@@ -12,16 +11,16 @@ impl Vecs {
         indexer: &Indexer,
         indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
-        starting_indexes: &Indexes,
         exit: &Exit,
     ) -> Result<()> {
         self.db.sync_bg_tasks()?;
 
-        self.spent.compute(indexer, starting_indexes, exit)?;
-        self.count
-            .compute(indexer, indexes, blocks, starting_indexes, exit)?;
-        self.per_sec.compute(&self.count, starting_indexes, exit)?;
-        self.by_type.compute(indexer, starting_indexes, exit)?;
+        let starting_lengths = indexer.safe_lengths();
+
+        self.spent.compute(indexer, exit)?;
+        self.count.compute(indexer, indexes, blocks, exit)?;
+        self.per_sec.compute(&self.count, &starting_lengths, exit)?;
+        self.by_type.compute(indexer, exit)?;
 
         let exit = exit.clone();
         self.db.run_bg(move |db| {

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

@@ -1,6 +1,5 @@
 use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_types::Indexes;
 use vecdb::Exit;
 
 use super::Vecs;
@@ -12,12 +11,12 @@ impl Vecs {
         indexer: &Indexer,
         indexes: &indexes::Vecs,
         blocks: &blocks::Vecs,
-        starting_indexes: &Indexes,
         exit: &Exit,
     ) -> Result<()> {
+        let starting_height = indexer.safe_lengths().height;
         let window_starts = blocks.lookback.window_starts();
         self.0.compute(
-            starting_indexes.height,
+            starting_height,
             &indexes.tx_index.input_count,
             &indexer.vecs.transactions.first_tx_index,
             &indexes.height.tx_index_count,

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

@@ -1,5 +1,6 @@
 use brk_error::Result;
-use brk_types::{Indexes, StoredF32};
+use brk_indexer::Lengths;
+use brk_types::StoredF32;
 use vecdb::Exit;
 
 use super::Vecs;
@@ -9,10 +10,10 @@ impl Vecs {
     pub(crate) fn compute(
         &mut self,
         count: &CountVecs,
-        starting_indexes: &Indexes,
+        starting_lengths: &Lengths,
         exit: &Exit,
     ) -> Result<()> {
-        let h = starting_indexes.height;
+        let h = starting_lengths.height;
         let sums = count.rolling.sum.0.as_array();
         let per_sec = self.0.as_mut_array();
         for (i, &secs) in Windows::<()>::SECS.iter().enumerate() {

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

@@ -1,6 +1,6 @@
 use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_types::{Indexes, Sats, TxIndex, TxOutIndex, Vout};
+use brk_types::{Sats, TxIndex, TxOutIndex, Vout};
 use rayon::prelude::*;
 use tracing::info;
 use vecdb::{AnyStoredVec, AnyVec, Exit, ReadableVec, VecIndex, WritableVec};
@@ -10,12 +10,8 @@ use super::Vecs;
 const BATCH_SIZE: usize = 2 * 1024 * 1024 * 1024 / size_of::<Entry>();
 
 impl Vecs {
-    pub(crate) fn compute(
-        &mut self,
-        indexer: &Indexer,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-    ) -> Result<()> {
+    pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
+        let starting_lengths = indexer.safe_lengths();
         // Validate computed versions against dependencies
         let dep_version = indexer.vecs.inputs.outpoint.version()
             + indexer.vecs.transactions.first_txout_index.version()
@@ -31,7 +27,7 @@ impl Vecs {
 
         let len1 = self.txout_index.len();
         let len2 = self.value.len();
-        let starting = starting_indexes.txin_index.to_usize();
+        let starting = starting_lengths.txin_index.to_usize();
         let min = len1.min(len2).min(starting);
 
         if min >= target {