global: fixes

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

@@ -61,7 +61,11 @@ impl Vecs {
                     Ok(())
                 },
                 |agg| {
-                    push_block(&mut self.input_count, agg.entries_all, &agg.entries_per_type);
+                    push_block(
+                        &mut self.input_count,
+                        agg.entries_all,
+                        &agg.entries_per_type,
+                    );
                     push_block(&mut self.tx_count, agg.txs_all, &agg.txs_per_type);
 
                     if self.input_count.all.block.batch_limit_reached() {
@@ -81,8 +85,7 @@ impl Vecs {
 
             self.input_count
                 .compute_rest(starting_indexes.height, exit)?;
-            self.tx_count
-                .compute_rest(starting_indexes.height, exit)?;
+            self.tx_count.compute_rest(starting_indexes.height, exit)?;
         }
 
         for (otype, source) in self.input_count.by_type.iter_typed() {

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

@@ -6,9 +6,7 @@ use vecdb::Database;
 use super::{Vecs, WithInputTypes};
 use crate::{
     indexes,
-    internal::{
-        PerBlockCumulativeRolling, PercentCumulativeRolling, WindowStartVec, Windows,
-    },
+    internal::{PerBlockCumulativeRolling, PercentCumulativeRolling, WindowStartVec, Windows},
 };
 
 impl Vecs {
@@ -18,26 +16,24 @@ impl Vecs {
         indexes: &indexes::Vecs,
         cached_starts: &Windows<&WindowStartVec>,
     ) -> Result<Self> {
-        let input_count = WithInputTypes::<
-            PerBlockCumulativeRolling<StoredU64, StoredU64>,
-        >::forced_import_with(
-            db,
-            "input_count_bis",
-            |t| format!("{t}_prevout_count"),
-            version,
-            indexes,
-            cached_starts,
-        )?;
-        let tx_count = WithInputTypes::<
-            PerBlockCumulativeRolling<StoredU64, StoredU64>,
-        >::forced_import_with(
-            db,
-            "non_coinbase_tx_count",
-            |t| format!("tx_count_with_{t}_prevout"),
-            version,
-            indexes,
-            cached_starts,
-        )?;
+        let input_count =
+            WithInputTypes::<PerBlockCumulativeRolling<StoredU64, StoredU64>>::forced_import_with(
+                db,
+                "input_count_bis",
+                |t| format!("{t}_prevout_count"),
+                version,
+                indexes,
+                cached_starts,
+            )?;
+        let tx_count =
+            WithInputTypes::<PerBlockCumulativeRolling<StoredU64, StoredU64>>::forced_import_with(
+                db,
+                "non_coinbase_tx_count",
+                |t| format!("tx_count_with_{t}_prevout"),
+                version,
+                indexes,
+                cached_starts,
+            )?;
 
         let input_share = SpendableType::try_new(|_, name| {
             PercentCumulativeRolling::forced_import(

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

@@ -68,7 +68,9 @@ where
         dep_version: Version,
         at_height: Height,
     ) -> Result<()> {
-        self.all.block.validate_and_truncate(dep_version, at_height)?;
+        self.all
+            .block
+            .validate_and_truncate(dep_version, at_height)?;
         for v in self.by_type.iter_mut() {
             v.block.validate_and_truncate(dep_version, at_height)?;
         }

crates/brk_computer/src/inputs/compute.rs

@@ -20,8 +20,7 @@ impl Vecs {
         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.per_sec.compute(&self.count, starting_indexes, exit)?;
         self.by_type.compute(indexer, starting_indexes, exit)?;
 
         let exit = exit.clone();