global: adding support for safe lengths

crates/brk_computer/src/pools/major.rs

@@ -1,6 +1,7 @@
 use brk_error::Result;
+use brk_indexer::Indexer;
 use brk_traversable::Traversable;
-use brk_types::{BasisPoints16, Height, Indexes, PoolSlug, StoredU64};
+use brk_types::{BasisPoints16, Height, PoolSlug, StoredU64};
 use derive_more::{Deref, DerefMut};
 use vecdb::{BinaryTransform, Database, Exit, ReadableVec, Rw, StorageMode, Version};
 
@@ -59,14 +60,16 @@ impl Vecs {
 
     pub(crate) fn compute(
         &mut self,
-        starting_indexes: &Indexes,
+        indexer: &Indexer,
         pool: &impl ReadableVec<Height, PoolSlug>,
         blocks: &blocks::Vecs,
         prices: &prices::Vecs,
         mining: &mining::Vecs,
         exit: &Exit,
     ) -> Result<()> {
-        self.base.compute(starting_indexes, pool, blocks, exit)?;
+        let starting_height = indexer.safe_lengths().height;
+
+        self.base.compute(indexer, pool, blocks, exit)?;
 
         for (dom, (mined, total)) in self.dominance_rolling.as_mut_array().into_iter().zip(
             self.base
@@ -77,23 +80,22 @@ impl Vecs {
                 .zip(blocks.count.total.sum.as_array()),
         ) {
             dom.compute_binary::<StoredU64, StoredU64, RatioU64Bp16>(
-                starting_indexes.height,
+                starting_height,
                 &mined.height,
                 &total.height,
                 exit,
             )?;
         }
 
-        self.rewards
-            .compute(starting_indexes.height, prices, exit, |vec| {
-                Ok(vec.compute_transform2(
-                    starting_indexes.height,
-                    &self.base.blocks_mined.block,
-                    &mining.rewards.coinbase.block.sats,
-                    |(h, mask, val, ..)| (h, MaskSats::apply(mask, val)),
-                    exit,
-                )?)
-            })?;
+        self.rewards.compute(starting_height, prices, exit, |vec| {
+            Ok(vec.compute_transform2(
+                starting_height,
+                &self.base.blocks_mined.block,
+                &mining.rewards.coinbase.block.sats,
+                |(h, mask, val, ..)| (h, MaskSats::apply(mask, val)),
+                exit,
+            )?)
+        })?;
 
         Ok(())
     }

crates/brk_computer/src/pools/minor.rs

@@ -1,6 +1,7 @@
 use brk_error::Result;
+use brk_indexer::Indexer;
 use brk_traversable::Traversable;
-use brk_types::{BasisPoints16, Height, Indexes, PoolSlug, StoredU32, StoredU64};
+use brk_types::{BasisPoints16, Height, PoolSlug, StoredU32, StoredU64};
 use vecdb::{Database, Exit, ReadableVec, Rw, StorageMode, Version};
 
 use crate::{
@@ -46,34 +47,35 @@ impl Vecs {
 
     pub(crate) fn compute(
         &mut self,
-        starting_indexes: &Indexes,
+        indexer: &Indexer,
         pool: &impl ReadableVec<Height, PoolSlug>,
         blocks: &blocks::Vecs,
         exit: &Exit,
     ) -> Result<()> {
-        self.blocks_mined
-            .compute(starting_indexes.height, exit, |vec| {
-                vec.compute_transform(
-                    starting_indexes.height,
-                    pool,
-                    |(h, id, ..)| {
-                        (
-                            h,
-                            if id == self.slug {
-                                StoredU32::ONE
-                            } else {
-                                StoredU32::ZERO
-                            },
-                        )
-                    },
-                    exit,
-                )?;
-                Ok(())
-            })?;
+        let starting_height = indexer.safe_lengths().height;
+
+        self.blocks_mined.compute(starting_height, exit, |vec| {
+            vec.compute_transform(
+                starting_height,
+                pool,
+                |(h, id, ..)| {
+                    (
+                        h,
+                        if id == self.slug {
+                            StoredU32::ONE
+                        } else {
+                            StoredU32::ZERO
+                        },
+                    )
+                },
+                exit,
+            )?;
+            Ok(())
+        })?;
 
         self.dominance
             .compute_binary::<StoredU64, StoredU64, RatioU64Bp16>(
-                starting_indexes.height,
+                starting_height,
                 &self.blocks_mined.cumulative.height,
                 &blocks.count.total.cumulative.height,
                 exit,

crates/brk_computer/src/pools/mod.rs

@@ -3,7 +3,7 @@ use std::{collections::BTreeMap, path::Path};
 use brk_error::Result;
 use brk_indexer::Indexer;
 use brk_traversable::Traversable;
-use brk_types::{Addr, AddrBytes, Height, Indexes, OutputType, PoolSlug, Pools, TxOutIndex, pools};
+use brk_types::{Addr, AddrBytes, Height, OutputType, PoolSlug, Pools, TxOutIndex, pools};
 use rayon::prelude::*;
 use vecdb::{
     AnyStoredVec, AnyVec, BytesVec, Database, Exit, ImportableVec, ReadableVec, Rw, StorageMode,
@@ -92,20 +92,19 @@ impl Vecs {
         blocks: &blocks::Vecs,
         prices: &prices::Vecs,
         mining: &mining::Vecs,
-        starting_indexes: &Indexes,
         exit: &Exit,
     ) -> Result<()> {
         self.db.sync_bg_tasks()?;
 
-        self.compute_pool(indexer, indexes, starting_indexes, exit)?;
+        self.compute_pool(indexer, indexes, exit)?;
 
         self.major.par_iter_mut().try_for_each(|(_, vecs)| {
-            vecs.compute(starting_indexes, &self.pool, blocks, prices, mining, exit)
+            vecs.compute(indexer, &self.pool, blocks, prices, mining, exit)
         })?;
 
         self.minor
             .par_iter_mut()
-            .try_for_each(|(_, vecs)| vecs.compute(starting_indexes, &self.pool, blocks, exit))?;
+            .try_for_each(|(_, vecs)| vecs.compute(indexer, &self.pool, blocks, exit))?;
 
         let exit = exit.clone();
         self.db.run_bg(move |db| {
@@ -119,9 +118,10 @@ impl Vecs {
         &mut self,
         indexer: &Indexer,
         indexes: &indexes::Vecs,
-        starting_indexes: &Indexes,
         exit: &Exit,
     ) -> Result<()> {
+        let starting_height = indexer.safe_lengths().height;
+
         let dep_version = indexer.vecs.blocks.coinbase_tag.version();
         let pool_vec_version = self.pool.header().vec_version();
         let pool_computed = self.pool.header().computed_version();
@@ -148,7 +148,7 @@ impl Vecs {
 
         let unknown = self.pools.get_unknown();
 
-        let min = starting_indexes.height.to_usize().min(self.pool.len());
+        let min = starting_height.to_usize().min(self.pool.len());
 
         // Cursors avoid per-height PcoVec page decompression.
         // Heights are sequential, tx_index values derived from them are monotonically