global: MASSIVE snapshot

crates/brk_computer/src/transactions/volume/compute.rs

@@ -1,18 +1,19 @@
 use brk_error::Result;
 use brk_indexer::Indexer;
-use brk_types::{ONE_DAY_IN_SEC_F64, StoredF32};
+use brk_types::StoredF32;
 use vecdb::Exit;
 
-use super::super::{count, fees};
 use super::Vecs;
-use crate::{ComputeIndexes, indexes, inputs, outputs};
+use crate::{blocks, ComputeIndexes, indexes, inputs, outputs};
+use crate::transactions::{count, fees};
 
 impl Vecs {
     #[allow(clippy::too_many_arguments)]
-    pub fn compute(
+    pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
         indexes: &indexes::Vecs,
+        blocks: &blocks::Vecs,
         count_vecs: &count::Vecs,
         fees_vecs: &fees::Vecs,
         inputs_count: &inputs::CountVecs,
@@ -20,115 +21,81 @@ impl Vecs {
         starting_indexes: &ComputeIndexes,
         exit: &Exit,
     ) -> Result<()> {
-        self.sent_sum
-            .compute_all(indexes, starting_indexes, exit, |v| {
-                v.compute_filtered_sum_from_indexes(
-                    starting_indexes.height,
-                    &indexer.vecs.transactions.first_txindex,
-                    &indexes.height.txindex_count,
-                    &fees_vecs.input_value,
-                    |sats| !sats.is_max(),
-                    exit,
-                )?;
-                Ok(())
-            })?;
+        self.sent_sum.sats.height.compute_filtered_sum_from_indexes(
+            starting_indexes.height,
+            &indexer.vecs.transactions.first_txindex,
+            &indexes.height.txindex_count,
+            &fees_vecs.input_value,
+            |sats| !sats.is_max(),
+            exit,
+        )?;
 
-        self.received_sum
-            .compute_all(indexes, starting_indexes, exit, |v| {
-                v.compute_sum_from_indexes(
-                    starting_indexes.height,
-                    &indexer.vecs.transactions.first_txindex,
-                    &indexes.height.txindex_count,
-                    &fees_vecs.output_value,
-                    exit,
-                )?;
-                Ok(())
-            })?;
+        self.received_sum.sats.height.compute_sum_from_indexes(
+            starting_indexes.height,
+            &indexer.vecs.transactions.first_txindex,
+            &indexes.height.txindex_count,
+            &fees_vecs.output_value,
+            exit,
+        )?;
 
-        self.annualized_volume.compute_sats(|v| {
-            v.compute_sum(
-                starting_indexes.dateindex,
-                &self.sent_sum.sats.dateindex.0,
-                365,
-                exit,
-            )?;
-            Ok(())
-        })?;
+        // Annualized volume: rolling 1y sum of per-block sent volume
+        self.annualized_volume.sats.height.compute_rolling_sum(
+            starting_indexes.height,
+            &blocks.count.height_1y_ago,
+            &self.sent_sum.sats.height,
+            exit,
+        )?;
 
-        if let Some(sent_sum_dollars) = self.sent_sum.dollars.as_ref() {
-            self.annualized_volume.compute_dollars(|dollars| {
-                dollars.compute_all(starting_indexes, exit, |v| {
-                    v.compute_sum(
-                        starting_indexes.dateindex,
-                        &sent_sum_dollars.dateindex.0,
-                        365,
-                        exit,
-                    )?;
-                    Ok(())
-                })
-            })?;
-        }
+        // tx_per_sec: per-block tx count / block interval
+        self.tx_per_sec.height.compute_transform2(
+            starting_indexes.height,
+            &count_vecs.tx_count.height,
+            &blocks.interval.interval.height,
+            |(h, tx_count, interval, ..)| {
+                let interval_f64 = f64::from(*interval);
+                let per_sec = if interval_f64 > 0.0 {
+                    StoredF32::from(*tx_count as f64 / interval_f64)
+                } else {
+                    StoredF32::NAN
+                };
+                (h, per_sec)
+            },
+            exit,
+        )?;
 
-        self.tx_per_sec.compute_all(starting_indexes, exit, |v| {
-            v.compute_transform2(
-                starting_indexes.dateindex,
-                &count_vecs.tx_count.dateindex.sum_cum.sum.0,
-                &indexes.dateindex.date,
-                |(i, tx_count, date, ..)| {
-                    let completion = date.completion();
-                    let per_sec = if completion == 0.0 {
-                        StoredF32::NAN
-                    } else {
-                        StoredF32::from(*tx_count as f64 / (completion * ONE_DAY_IN_SEC_F64))
-                    };
-                    (i, per_sec)
-                },
-                exit,
-            )?;
-            Ok(())
-        })?;
+        // inputs_per_sec: per-block input count / block interval
+        self.inputs_per_sec.height.compute_transform2(
+            starting_indexes.height,
+            &inputs_count.height.sum_cum.sum.0,
+            &blocks.interval.interval.height,
+            |(h, input_count, interval, ..)| {
+                let interval_f64 = f64::from(*interval);
+                let per_sec = if interval_f64 > 0.0 {
+                    StoredF32::from(*input_count as f64 / interval_f64)
+                } else {
+                    StoredF32::NAN
+                };
+                (h, per_sec)
+            },
+            exit,
+        )?;
 
-        self.inputs_per_sec
-            .compute_all(starting_indexes, exit, |v| {
-                v.compute_transform2(
-                    starting_indexes.dateindex,
-                    &inputs_count.dateindex.sum_cum.sum.0,
-                    &indexes.dateindex.date,
-                    |(i, input_count, date, ..)| {
-                        let completion = date.completion();
-                        let per_sec = if completion == 0.0 {
-                            StoredF32::NAN
-                        } else {
-                            StoredF32::from(*input_count as f64 / (completion * ONE_DAY_IN_SEC_F64))
-                        };
-                        (i, per_sec)
-                    },
-                    exit,
-                )?;
-                Ok(())
-            })?;
-
-        self.outputs_per_sec
-            .compute_all(starting_indexes, exit, |v| {
-                v.compute_transform2(
-                    starting_indexes.dateindex,
-                    &outputs_count.total_count.dateindex.sum_cum.sum.0,
-                    &indexes.dateindex.date,
-                    |(i, output_count, date, ..)| {
-                        let completion = date.completion();
-                        let per_sec = if completion == 0.0 {
-                            StoredF32::NAN
-                        } else {
-                            StoredF32::from(
-                                *output_count as f64 / (completion * ONE_DAY_IN_SEC_F64),
-                            )
-                        };
-                        (i, per_sec)
-                    },
-                    exit,
-                )?;
-                Ok(())
-            })?;
+        // outputs_per_sec: per-block output count / block interval
+        self.outputs_per_sec.height.compute_transform2(
+            starting_indexes.height,
+            &outputs_count.total_count.height.sum_cum.sum.0,
+            &blocks.interval.interval.height,
+            |(h, output_count, interval, ..)| {
+                let interval_f64 = f64::from(*interval);
+                let per_sec = if interval_f64 > 0.0 {
+                    StoredF32::from(*output_count as f64 / interval_f64)
+                } else {
+                    StoredF32::NAN
+                };
+                (h, per_sec)
+            },
+            exit,
+        )?;
 
         Ok(())
     }

crates/brk_computer/src/transactions/volume/import.rs

@@ -3,48 +3,49 @@ use brk_types::Version;
 use vecdb::Database;
 
 use super::Vecs;
-use crate::{indexes, internal::{ComputedFromDateLast, ValueFromHeightSum, ValueFromDateLast}, price};
+use crate::{
+    indexes,
+    internal::{ComputedFromHeightLast, ValueFromHeightLast, ValueFromHeightSum},
+    prices,
+};
 
 impl Vecs {
-    pub fn forced_import(
+    pub(crate) fn forced_import(
         db: &Database,
         version: Version,
         indexes: &indexes::Vecs,
-        price: Option<&price::Vecs>,
+        prices: &prices::Vecs,
     ) -> Result<Self> {
         let v2 = Version::TWO;
-        let compute_dollars = price.is_some();
-
         Ok(Self {
-            sent_sum: ValueFromHeightSum::forced_import(
-                db,
-                "sent_sum",
-                version,
-                indexes,
-                price,
-            )?,
+            sent_sum: ValueFromHeightSum::forced_import(db, "sent_sum", version, indexes, prices)?,
             received_sum: ValueFromHeightSum::forced_import(
                 db,
                 "received_sum",
                 version,
                 indexes,
-                price,
+                prices,
             )?,
-            annualized_volume: ValueFromDateLast::forced_import(
+            annualized_volume: ValueFromHeightLast::forced_import(
                 db,
                 "annualized_volume",
                 version,
-                compute_dollars,
+                indexes,
+                prices,
+            )?,
+            tx_per_sec: ComputedFromHeightLast::forced_import(
+                db,
+                "tx_per_sec",
+                version + v2,
                 indexes,
             )?,
-            tx_per_sec: ComputedFromDateLast::forced_import(db, "tx_per_sec", version + v2, indexes)?,
-            outputs_per_sec: ComputedFromDateLast::forced_import(
+            outputs_per_sec: ComputedFromHeightLast::forced_import(
                 db,
                 "outputs_per_sec",
                 version + v2,
                 indexes,
             )?,
-            inputs_per_sec: ComputedFromDateLast::forced_import(
+            inputs_per_sec: ComputedFromHeightLast::forced_import(
                 db,
                 "inputs_per_sec",
                 version + v2,

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

@@ -1,15 +1,16 @@
 use brk_traversable::Traversable;
 use brk_types::StoredF32;
+use vecdb::{Rw, StorageMode};
 
-use crate::internal::{ComputedFromDateLast, ValueFromHeightSum, ValueFromDateLast};
+use crate::internal::{ComputedFromHeightLast, ValueFromHeightLast, ValueFromHeightSum};
 
 /// Volume metrics
-#[derive(Clone, Traversable)]
-pub struct Vecs {
-    pub sent_sum: ValueFromHeightSum,
-    pub received_sum: ValueFromHeightSum,
-    pub annualized_volume: ValueFromDateLast,
-    pub tx_per_sec: ComputedFromDateLast<StoredF32>,
-    pub outputs_per_sec: ComputedFromDateLast<StoredF32>,
-    pub inputs_per_sec: ComputedFromDateLast<StoredF32>,
+#[derive(Traversable)]
+pub struct Vecs<M: StorageMode = Rw> {
+    pub sent_sum: ValueFromHeightSum<M>,
+    pub received_sum: ValueFromHeightSum<M>,
+    pub annualized_volume: ValueFromHeightLast<M>,
+    pub tx_per_sec: ComputedFromHeightLast<StoredF32, M>,
+    pub outputs_per_sec: ComputedFromHeightLast<StoredF32, M>,
+    pub inputs_per_sec: ComputedFromHeightLast<StoredF32, M>,
 }