vec: caching only in iter

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

@@ -209,14 +209,14 @@ impl Vecs {
         self.difficultyepoch_to_timestamp.compute_transform(
             starting_indexes.difficultyepoch,
             indexes.difficultyepoch_to_first_height.vec(),
-            |(i, h, ..)| (i, height_to_timestamp_iter.get(h).unwrap().1.into_inner()),
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
             exit,
         )?;
 
         self.halvingepoch_to_timestamp.compute_transform(
             starting_indexes.halvingepoch,
             indexes.halvingepoch_to_first_height.vec(),
-            |(i, h, ..)| (i, height_to_timestamp_iter.get(h).unwrap().1.into_inner()),
+            |(i, h, ..)| (i, height_to_timestamp_iter.unwrap_get_inner(h)),
             exit,
         )?;
 

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

@@ -186,12 +186,12 @@ where
             .try_for_each(|(i, first_index)| -> Result<()> {
                 let first_index = first_index.into_inner();
 
-                let count_index = count_indexes_iter.get(i).unwrap().1.into_inner();
+                let count_index = count_indexes_iter.unwrap_get_inner(i);
 
                 if let Some(first) = self.first.as_mut() {
                     let f = source_iter
-                        .get(first_index)
-                        .map_or(T::from(0_usize), |f| f.1.into_inner());
+                        .get_inner(first_index)
+                        .unwrap_or_else(|| T::from(0_usize));
                     first.forced_push_at(index, f, exit)?;
                 }
 
@@ -201,15 +201,13 @@ where
                         panic!("should compute last if count can be 0")
                     }
                     let last_index = first_index + (count_index - 1);
-                    let v = source_iter
-                        .get(last_index)
-                        .context("to work")
-                        .inspect_err(|_| {
-                            dbg!(first_index, count_index, last_index);
-                        })
-                        .unwrap()
-                        .1
-                        .into_inner();
+                    let v = source_iter.unwrap_get_inner(last_index);
+                    // .context("to work")
+                    // .inspect_err(|_| {
+                    //     dbg!(first_index, count_index, last_index);
+                    // })
+                    // .unwrap()
+                    // .into_inner();
                     last.forced_push_at(index, v, exit)?;
                 }
 
@@ -357,7 +355,7 @@ where
             .try_for_each(|(i, first_index, ..)| -> Result<()> {
                 let first_index = first_index.into_inner();
 
-                let count_index = count_indexes_iter.get(i).unwrap().1.into_inner();
+                let count_index = count_indexes_iter.unwrap_get_inner(i);
 
                 if let Some(first) = self.first.as_mut() {
                     let v = source_first_iter

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

@@ -342,9 +342,8 @@ impl Vecs {
                     .get_height(
                         h,
                         t,
-                        h.decremented().map(|prev_h| {
-                            height_to_timestamp_iter.get(prev_h).unwrap().1.into_inner()
-                        }),
+                        h.decremented()
+                            .map(|prev_h| height_to_timestamp_iter.unwrap_get_inner(prev_h)),
                     )
                     .unwrap();
                 (h, ohlc)

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

@@ -471,11 +471,7 @@ impl Vecs {
                             indexer.vecs().height_to_first_txindex.vec(),
                             indexer.vecs().txindex_to_txid.vec(),
                             |txindex| {
-                                let v = txindex_to_txversion_iter
-                                    .get(txindex)
-                                    .unwrap()
-                                    .1
-                                    .into_inner();
+                                let v = txindex_to_txversion_iter.unwrap_get_inner(txindex);
                                 v == txversion
                             },
                             exit,
@@ -499,11 +495,7 @@ impl Vecs {
             starting_indexes.txindex,
             indexer.vecs().txindex_to_base_size.vec(),
             |(txindex, base_size, ..)| {
-                let total_size = txindex_to_total_size_iter
-                    .get(txindex)
-                    .unwrap()
-                    .1
-                    .into_inner();
+                let total_size = txindex_to_total_size_iter.unwrap_get_inner(txindex);
 
                 // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
                 let wu = usize::from(base_size) * 3 + usize::from(total_size);
@@ -533,7 +525,7 @@ impl Vecs {
             |(inputindex, outputindex, ..)| {
                 let value = if outputindex == OutputIndex::COINBASE {
                     Sats::ZERO
-                } else if let Some((_, value)) = outputindex_to_value_iter.get(outputindex) {
+                } else if let Some(value) = outputindex_to_value_iter.get(outputindex) {
                     value.into_inner()
                 } else {
                     dbg!(inputindex, outputindex, inputs_len);

crates/brk_computer/src/storage/vecs/vec/eager.rs

@@ -12,7 +12,6 @@ use brk_vec::{
     Compressed, DynamicVec, Error, GenericVec, Result, StoredIndex, StoredType, StoredVec,
     StoredVecIterator, Value, Version,
 };
-use color_eyre::eyre::ContextCompat;
 use log::info;
 
 const ONE_KIB: usize = 1024;
@@ -223,11 +222,7 @@ where
             if prev_i.is_some_and(|prev_i| prev_i == i) {
                 return Ok(());
             }
-            if self
-                .inner
-                .get(i)?
-                .is_none_or(|old_v| old_v.into_inner() > v)
-            {
+            if self.iter().get_inner(i).is_none_or(|old_v| old_v > v) {
                 self.forced_push_at(i, v, exit)?;
             }
             prev_i.replace(i);
@@ -350,8 +345,8 @@ where
             .iter_at(index)
             .try_for_each(|(i, first_index)| {
                 let end = other_iter
-                    .get(i + 1)
-                    .map(|(_, v)| v.into_inner().unwrap_to_usize())
+                    .get_inner(i + 1)
+                    .map(|v| v.unwrap_to_usize())
                     .unwrap_or_else(|| other_to_else.len());
 
                 let range = first_index.unwrap_to_usize()..end;
@@ -387,14 +382,7 @@ where
         self_to_other.iter_at(index).try_for_each(|(i, other)| {
             self.forced_push_at(
                 i,
-                T::from(
-                    other_to_self_iter
-                        .get(other.into_inner())
-                        .unwrap()
-                        .1
-                        .into_inner()
-                        == i,
-                ),
+                T::from(other_to_self_iter.unwrap_get_inner(other.into_inner()) == i),
                 exit,
             )
         })?;
@@ -424,12 +412,12 @@ where
         first_indexes
             .iter_at(index)
             .try_for_each(|(i, first_index)| {
-                let count = *indexes_count_iter.get(i).unwrap().1.into_inner();
+                let count = *indexes_count_iter.unwrap_get_inner(i);
                 let first_index = first_index.unwrap_to_usize();
                 let range = first_index..first_index + count;
                 let mut sum = T::from(0_usize);
                 range.into_iter().for_each(|i| {
-                    sum = sum.clone() + source_iter.get(T2::from(i)).unwrap().1.into_inner();
+                    sum = sum.clone() + source_iter.unwrap_get_inner(T2::from(i));
                 });
                 self.forced_push_at(i, sum, exit)
             })?;
@@ -477,7 +465,7 @@ impl EagerVec<Height, Dollars> {
         let mut price_iter = price.iter();
         let index = max_from.min(Height::from(self.len()));
         bitcoin.iter_at(index).try_for_each(|(i, bitcoin)| {
-            let dollars = price_iter.get(i).unwrap().1.into_inner();
+            let dollars = price_iter.unwrap_get_inner(i);
             let (i, v) = (i, *dollars * bitcoin.into_inner());
             self.forced_push_at(i, v, exit)
         })?;
@@ -503,8 +491,8 @@ impl EagerVec<TxIndex, Dollars> {
         let mut price_iter = price.iter();
         let index = max_from.min(TxIndex::from(self.len()));
         bitcoin.iter_at(index).try_for_each(|(i, bitcoin, ..)| {
-            let height = i_to_height_iter.get(i).unwrap().1.into_inner();
-            let dollars = price_iter.get(height).unwrap().1.into_inner();
+            let height = i_to_height_iter.unwrap_get_inner(i);
+            let dollars = price_iter.unwrap_get_inner(height);
             let (i, v) = (i, *dollars * bitcoin.into_inner());
             self.forced_push_at(i, v, exit)
         })?;