global: snapshot

crates/brk_computer/src/supply/compute.rs

@@ -44,16 +44,8 @@ impl Vecs {
         self.velocity
             .compute(blocks, transactions, distribution, starting_indexes, exit)?;
 
-        // 4. Compute cap growth rates using 1y lookback
-        self.market_cap_growth_rate
-            .bps
-            .height
-            .compute_rolling_ratio_change(
-                starting_indexes.height,
-                &blocks.count.height_1y_ago,
-                &self.market_cap.height,
-                exit,
-            )?;
+        // 4. Compute cap growth rates across 4 windows
+        let window_starts = blocks.count.window_starts();
 
         let realized_cap = &distribution
             .utxo_cohorts
@@ -62,25 +54,32 @@ impl Vecs {
             .realized
             .realized_cap
             .height;
-        self.realized_cap_growth_rate
-            .bps
-            .height
-            .compute_rolling_ratio_change(
+
+        let mcgr_arr = self.market_cap_growth_rate.0.as_mut_array();
+        let rcgr_arr = self.realized_cap_growth_rate.0.as_mut_array();
+        let diff_arr = self.market_minus_realized_cap_growth_rate.0.as_mut_array();
+        let starts_arr = window_starts.as_array();
+
+        for i in 0..4 {
+            mcgr_arr[i].bps.height.compute_rolling_ratio_change(
                 starting_indexes.height,
-                &blocks.count.height_1y_ago,
+                *starts_arr[i],
+                &self.market_cap.height,
+                exit,
+            )?;
+            rcgr_arr[i].bps.height.compute_rolling_ratio_change(
+                starting_indexes.height,
+                *starts_arr[i],
                 realized_cap,
                 exit,
             )?;
-
-        // 5. Compute cap growth rate diff: market - realized
-        self.market_minus_realized_cap_growth_rate
-            .height
-            .compute_subtract(
+            diff_arr[i].height.compute_subtract(
                 starting_indexes.height,
-                &self.market_cap_growth_rate.bps.height,
-                &self.realized_cap_growth_rate.bps.height,
+                &mcgr_arr[i].bps.height,
+                &rcgr_arr[i].bps.height,
                 exit,
             )?;
+        }
 
         let _lock = exit.lock();
         self.db.compact()?;

crates/brk_computer/src/supply/import.rs

@@ -6,8 +6,8 @@ use brk_types::{Cents, Dollars, Sats, Version};
 use crate::{
     distribution, indexes,
     internal::{
-        ComputedFromHeight, Identity, LazyFromHeight, LazyValueFromHeight, PercentFromHeight,
-        SatsToBitcoin, finalize_db, open_db,
+        Identity, LazyFromHeight, LazyValueFromHeight, PercentFromHeight, PercentRollingWindows,
+        RollingWindows, SatsToBitcoin, finalize_db, open_db,
     },
 };
 
@@ -52,23 +52,23 @@ impl Vecs {
             &supply_metrics.total.usd,
         );
 
-        // Growth rates
-        let market_cap_growth_rate = PercentFromHeight::forced_import(
+        // Growth rates (4 windows: 24h, 1w, 1m, 1y)
+        let market_cap_growth_rate = PercentRollingWindows::forced_import(
             &db,
             "market_cap_growth_rate",
-            version + Version::ONE,
+            version + Version::TWO,
             indexes,
         )?;
-        let realized_cap_growth_rate = PercentFromHeight::forced_import(
+        let realized_cap_growth_rate = PercentRollingWindows::forced_import(
             &db,
             "realized_cap_growth_rate",
-            version + Version::ONE,
+            version + Version::TWO,
             indexes,
         )?;
-        let market_minus_realized_cap_growth_rate = ComputedFromHeight::forced_import(
+        let market_minus_realized_cap_growth_rate = RollingWindows::forced_import(
             &db,
             "market_minus_realized_cap_growth_rate",
-            version,
+            version + Version::ONE,
             indexes,
         )?;
 

crates/brk_computer/src/supply/vecs.rs

@@ -3,7 +3,9 @@ use brk_types::{BasisPointsSigned32, Dollars};
 use vecdb::{Database, Rw, StorageMode};
 
 use super::{burned, velocity};
-use crate::internal::{ComputedFromHeight, LazyFromHeight, LazyValueFromHeight, PercentFromHeight};
+use crate::internal::{
+    LazyFromHeight, LazyValueFromHeight, PercentFromHeight, PercentRollingWindows, RollingWindows,
+};
 
 #[derive(Traversable)]
 pub struct Vecs<M: StorageMode = Rw> {
@@ -15,7 +17,7 @@ pub struct Vecs<M: StorageMode = Rw> {
     pub inflation_rate: PercentFromHeight<BasisPointsSigned32, M>,
     pub velocity: velocity::Vecs<M>,
     pub market_cap: LazyFromHeight<Dollars>,
-    pub market_cap_growth_rate: PercentFromHeight<BasisPointsSigned32, M>,
-    pub realized_cap_growth_rate: PercentFromHeight<BasisPointsSigned32, M>,
-    pub market_minus_realized_cap_growth_rate: ComputedFromHeight<BasisPointsSigned32, M>,
+    pub market_cap_growth_rate: PercentRollingWindows<BasisPointsSigned32, M>,
+    pub realized_cap_growth_rate: PercentRollingWindows<BasisPointsSigned32, M>,
+    pub market_minus_realized_cap_growth_rate: RollingWindows<BasisPointsSigned32, M>,
 }