computer: indexes + rolling

crates/brk_computer/src/inputs/compute.rs

@@ -3,20 +3,21 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{indexes, ComputeIndexes};
+use crate::{blocks, indexes, ComputeIndexes};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
         indexes: &indexes::Vecs,
+        blocks: &blocks::Vecs,
         starting_indexes: &ComputeIndexes,
         exit: &Exit,
     ) -> Result<()> {
         self.spent
             .compute(&self.db, indexer, starting_indexes, exit)?;
         self.count
-            .compute(indexer, indexes, starting_indexes, exit)?;
+            .compute(indexer, indexes, blocks, starting_indexes, exit)?;
 
         let _lock = exit.lock();
         self.db.compact()?;

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

@@ -3,23 +3,34 @@ use brk_indexer::Indexer;
 use vecdb::Exit;
 
 use super::Vecs;
-use crate::{ComputeIndexes, indexes};
+use crate::{blocks, indexes, ComputeIndexes};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
         indexes: &indexes::Vecs,
+        blocks: &blocks::Vecs,
         starting_indexes: &ComputeIndexes,
         exit: &Exit,
     ) -> Result<()> {
-        self.derive_from(
-            indexer,
-            indexes,
-            starting_indexes,
+        self.height.compute_with_skip(
+            starting_indexes.height,
             &indexes.txindex.input_count,
+            &indexer.vecs.transactions.first_txindex,
+            &indexes.height.txindex_count,
+            exit,
+            0,
+        )?;
+
+        let window_starts = blocks.count.window_starts();
+        self.rolling.compute(
+            starting_indexes.height,
+            &window_starts,
+            self.height.sum_cum.sum.inner(),
             exit,
         )?;
+
         Ok(())
     }
 }

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

@@ -3,15 +3,16 @@ use brk_types::Version;
 use vecdb::Database;
 
 use super::Vecs;
-use crate::{indexes, internal::TxDerivedFull};
+use crate::{
+    indexes,
+    internal::{Full, RollingFull},
+};
 
 impl Vecs {
     pub(crate) fn forced_import(db: &Database, version: Version, indexes: &indexes::Vecs) -> Result<Self> {
-        Ok(Self(TxDerivedFull::forced_import(
-            db,
-            "input_count",
-            version,
-            indexes,
-        )?))
+        Ok(Self {
+            height: Full::forced_import(db, "input_count", version)?,
+            rolling: RollingFull::forced_import(db, "input_count", version, indexes)?,
+        })
     }
 }

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

@@ -1,9 +1,11 @@
 use brk_traversable::Traversable;
-use brk_types::StoredU64;
-use derive_more::{Deref, DerefMut};
+use brk_types::{Height, StoredU64};
 use vecdb::{Rw, StorageMode};
 
-use crate::internal::TxDerivedFull;
+use crate::internal::{Full, RollingFull};
 
-#[derive(Deref, DerefMut, Traversable)]
-pub struct Vecs<M: StorageMode = Rw>(pub TxDerivedFull<StoredU64, M>);
+#[derive(Traversable)]
+pub struct Vecs<M: StorageMode = Rw> {
+    pub height: Full<Height, StoredU64, M>,
+    pub rolling: RollingFull<StoredU64, M>,
+}