global: snapshot

crates/brk_computer/src/distribution/metrics/activity/base.rs

@@ -1,68 +1,37 @@
 use brk_error::Result;
 use brk_traversable::Traversable;
-use brk_types::{Bitcoin, Height, Indexes, Sats, StoredF64, Version};
-use derive_more::{Deref, DerefMut};
+use brk_types::{Height, Indexes, Sats, Version};
 use vecdb::{AnyStoredVec, AnyVec, Exit, Rw, StorageMode, WritableVec};
 
-use crate::internal::ComputedFromHeightCumulativeSum;
+use crate::internal::{RollingEmas2w, ValueFromHeightCumulative};
 
 use crate::{blocks, distribution::metrics::ImportConfig, prices};
 
-use super::ActivityCore;
-
-#[derive(Deref, DerefMut, Traversable)]
-pub struct ActivityMetrics<M: StorageMode = Rw> {
-    #[deref]
-    #[deref_mut]
-    #[traversable(flatten)]
-    pub core: ActivityCore<M>,
-
-    pub coinblocks_destroyed: ComputedFromHeightCumulativeSum<StoredF64, M>,
-    pub coindays_destroyed: ComputedFromHeightCumulativeSum<StoredF64, M>,
+#[derive(Traversable)]
+pub struct ActivityBase<M: StorageMode = Rw> {
+    pub sent: ValueFromHeightCumulative<M>,
+    pub sent_ema: RollingEmas2w<M>,
 }
 
-impl ActivityMetrics {
+impl ActivityBase {
     pub(crate) fn forced_import(cfg: &ImportConfig) -> Result<Self> {
         Ok(Self {
-            core: ActivityCore::forced_import(cfg)?,
-            coinblocks_destroyed: cfg
-                .import_cumulative_sum("coinblocks_destroyed", Version::ONE)?,
-            coindays_destroyed: cfg.import_cumulative_sum("coindays_destroyed", Version::ONE)?,
+            sent: cfg.import_value_cumulative("sent", Version::ZERO)?,
+            sent_ema: cfg.import_emas_2w("sent", Version::ZERO)?,
         })
     }
 
     pub(crate) fn min_len(&self) -> usize {
-        self.core
-            .min_len()
-            .min(self.coinblocks_destroyed.height.len())
-            .min(self.coindays_destroyed.height.len())
+        self.sent.base.sats.height.len()
     }
 
-    pub(crate) fn truncate_push(
-        &mut self,
-        height: Height,
-        sent: Sats,
-        satblocks_destroyed: Sats,
-        satdays_destroyed: Sats,
-    ) -> Result<()> {
-        self.core.truncate_push(height, sent)?;
-        self.coinblocks_destroyed.height.truncate_push(
-            height,
-            StoredF64::from(Bitcoin::from(satblocks_destroyed)),
-        )?;
-        self.coindays_destroyed.height.truncate_push(
-            height,
-            StoredF64::from(Bitcoin::from(satdays_destroyed)),
-        )?;
+    pub(crate) fn truncate_push(&mut self, height: Height, sent: Sats) -> Result<()> {
+        self.sent.base.sats.height.truncate_push(height, sent)?;
         Ok(())
     }
 
     pub(crate) fn collect_vecs_mut(&mut self) -> Vec<&mut dyn AnyStoredVec> {
-        vec![
-            &mut self.core.sent.base.sats.height as &mut dyn AnyStoredVec,
-            &mut self.coinblocks_destroyed.height as &mut dyn AnyStoredVec,
-            &mut self.coindays_destroyed.height as &mut dyn AnyStoredVec,
-        ]
+        vec![&mut self.sent.base.sats.height as &mut dyn AnyStoredVec]
     }
 
     pub(crate) fn validate_computed_versions(&mut self, _base_version: Version) -> Result<()> {
@@ -75,12 +44,14 @@ impl ActivityMetrics {
         others: &[&Self],
         exit: &Exit,
     ) -> Result<()> {
-        let core_refs: Vec<&ActivityCore> = others.iter().map(|o| &o.core).collect();
-        self.core
-            .compute_from_stateful(starting_indexes, &core_refs, exit)?;
-
-        sum_others!(self, starting_indexes, others, exit; coinblocks_destroyed.height);
-        sum_others!(self, starting_indexes, others, exit; coindays_destroyed.height);
+        self.sent.base.sats.height.compute_sum_of_others(
+            starting_indexes.height,
+            &others
+                .iter()
+                .map(|v| &v.sent.base.sats.height)
+                .collect::<Vec<_>>(),
+            exit,
+        )?;
         Ok(())
     }
 
@@ -91,16 +62,16 @@ impl ActivityMetrics {
         starting_indexes: &Indexes,
         exit: &Exit,
     ) -> Result<()> {
-        self.core
-            .compute_rest_part1(blocks, prices, starting_indexes, exit)?;
+        self.sent
+            .compute(prices, starting_indexes.height, exit)?;
 
-        let window_starts = blocks.count.window_starts();
-
-        self.coinblocks_destroyed
-            .compute_rest(starting_indexes.height, &window_starts, exit)?;
-
-        self.coindays_destroyed
-            .compute_rest(starting_indexes.height, &window_starts, exit)?;
+        self.sent_ema.compute(
+            starting_indexes.height,
+            &blocks.count.height_2w_ago,
+            &self.sent.base.sats.height,
+            &self.sent.base.cents.height,
+            exit,
+        )?;
 
         Ok(())
     }

crates/brk_computer/src/distribution/metrics/activity/core.rs

@@ -1,78 +0,0 @@
-use brk_error::Result;
-use brk_traversable::Traversable;
-use brk_types::{Height, Indexes, Sats, Version};
-use vecdb::{AnyStoredVec, AnyVec, Exit, Rw, StorageMode, WritableVec};
-
-use crate::internal::{RollingEmas2w, ValueFromHeightCumulative};
-
-use crate::{blocks, distribution::metrics::ImportConfig, prices};
-
-#[derive(Traversable)]
-pub struct ActivityCore<M: StorageMode = Rw> {
-    pub sent: ValueFromHeightCumulative<M>,
-    pub sent_ema: RollingEmas2w<M>,
-}
-
-impl ActivityCore {
-    pub(crate) fn forced_import(cfg: &ImportConfig) -> Result<Self> {
-        Ok(Self {
-            sent: cfg.import_value_cumulative("sent", Version::ZERO)?,
-            sent_ema: cfg.import_emas_2w("sent", Version::ZERO)?,
-        })
-    }
-
-    pub(crate) fn min_len(&self) -> usize {
-        self.sent.base.sats.height.len()
-    }
-
-    pub(crate) fn truncate_push(&mut self, height: Height, sent: Sats) -> Result<()> {
-        self.sent.base.sats.height.truncate_push(height, sent)?;
-        Ok(())
-    }
-
-    pub(crate) fn collect_vecs_mut(&mut self) -> Vec<&mut dyn AnyStoredVec> {
-        vec![&mut self.sent.base.sats.height as &mut dyn AnyStoredVec]
-    }
-
-    pub(crate) fn validate_computed_versions(&mut self, _base_version: Version) -> Result<()> {
-        Ok(())
-    }
-
-    pub(crate) fn compute_from_stateful(
-        &mut self,
-        starting_indexes: &Indexes,
-        others: &[&Self],
-        exit: &Exit,
-    ) -> Result<()> {
-        self.sent.base.sats.height.compute_sum_of_others(
-            starting_indexes.height,
-            &others
-                .iter()
-                .map(|v| &v.sent.base.sats.height)
-                .collect::<Vec<_>>(),
-            exit,
-        )?;
-        Ok(())
-    }
-
-    pub(crate) fn compute_rest_part1(
-        &mut self,
-        blocks: &blocks::Vecs,
-        prices: &prices::Vecs,
-        starting_indexes: &Indexes,
-        exit: &Exit,
-    ) -> Result<()> {
-        self.sent
-            .compute(prices, starting_indexes.height, exit)?;
-
-        self.sent_ema.compute(
-            starting_indexes.height,
-            &blocks.count.height_2w_ago,
-            &self.sent.base.sats.height,
-            &self.sent.base.cents.height,
-            exit,
-        )?;
-
-        Ok(())
-    }
-}

crates/brk_computer/src/distribution/metrics/activity/full.rs

@@ -0,0 +1,107 @@
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Bitcoin, Height, Indexes, Sats, StoredF64, Version};
+use derive_more::{Deref, DerefMut};
+use vecdb::{AnyStoredVec, AnyVec, Exit, Rw, StorageMode, WritableVec};
+
+use crate::internal::ComputedFromHeightCumulativeSum;
+
+use crate::{blocks, distribution::metrics::ImportConfig, prices};
+
+use super::ActivityBase;
+
+#[derive(Deref, DerefMut, Traversable)]
+pub struct ActivityFull<M: StorageMode = Rw> {
+    #[deref]
+    #[deref_mut]
+    #[traversable(flatten)]
+    pub base: ActivityBase<M>,
+
+    pub coinblocks_destroyed: ComputedFromHeightCumulativeSum<StoredF64, M>,
+    pub coindays_destroyed: ComputedFromHeightCumulativeSum<StoredF64, M>,
+}
+
+impl ActivityFull {
+    pub(crate) fn forced_import(cfg: &ImportConfig) -> Result<Self> {
+        Ok(Self {
+            base: ActivityBase::forced_import(cfg)?,
+            coinblocks_destroyed: cfg
+                .import_cumulative_sum("coinblocks_destroyed", Version::ONE)?,
+            coindays_destroyed: cfg.import_cumulative_sum("coindays_destroyed", Version::ONE)?,
+        })
+    }
+
+    pub(crate) fn min_len(&self) -> usize {
+        self.base
+            .min_len()
+            .min(self.coinblocks_destroyed.height.len())
+            .min(self.coindays_destroyed.height.len())
+    }
+
+    pub(crate) fn truncate_push(
+        &mut self,
+        height: Height,
+        sent: Sats,
+        satblocks_destroyed: Sats,
+        satdays_destroyed: Sats,
+    ) -> Result<()> {
+        self.base.truncate_push(height, sent)?;
+        self.coinblocks_destroyed.height.truncate_push(
+            height,
+            StoredF64::from(Bitcoin::from(satblocks_destroyed)),
+        )?;
+        self.coindays_destroyed.height.truncate_push(
+            height,
+            StoredF64::from(Bitcoin::from(satdays_destroyed)),
+        )?;
+        Ok(())
+    }
+
+    pub(crate) fn collect_vecs_mut(&mut self) -> Vec<&mut dyn AnyStoredVec> {
+        vec![
+            &mut self.base.sent.base.sats.height as &mut dyn AnyStoredVec,
+            &mut self.coinblocks_destroyed.height as &mut dyn AnyStoredVec,
+            &mut self.coindays_destroyed.height as &mut dyn AnyStoredVec,
+        ]
+    }
+
+    pub(crate) fn validate_computed_versions(&mut self, _base_version: Version) -> Result<()> {
+        Ok(())
+    }
+
+    pub(crate) fn compute_from_stateful(
+        &mut self,
+        starting_indexes: &Indexes,
+        others: &[&Self],
+        exit: &Exit,
+    ) -> Result<()> {
+        let core_refs: Vec<&ActivityBase> = others.iter().map(|o| &o.base).collect();
+        self.base
+            .compute_from_stateful(starting_indexes, &core_refs, exit)?;
+
+        sum_others!(self, starting_indexes, others, exit; coinblocks_destroyed.height);
+        sum_others!(self, starting_indexes, others, exit; coindays_destroyed.height);
+        Ok(())
+    }
+
+    pub(crate) fn compute_rest_part1(
+        &mut self,
+        blocks: &blocks::Vecs,
+        prices: &prices::Vecs,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.base
+            .compute_rest_part1(blocks, prices, starting_indexes, exit)?;
+
+        let window_starts = blocks.count.window_starts();
+
+        self.coinblocks_destroyed
+            .compute_rest(starting_indexes.height, &window_starts, exit)?;
+
+        self.coindays_destroyed
+            .compute_rest(starting_indexes.height, &window_starts, exit)?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/distribution/metrics/activity/mod.rs

@@ -1,5 +1,5 @@
 mod base;
-mod core;
+mod full;
 
 pub use base::*;
-pub use core::*;
+pub use full::*;