global: MASSIVE snapshot

crates/brk_computer/src/cointime/activity/compute.rs

@@ -0,0 +1,98 @@
+use brk_error::Result;
+use brk_types::{Bitcoin, CheckedSub, StoredF64};
+use vecdb::{Exit, TypedVecIterator};
+
+use super::Vecs;
+use crate::{distribution, indexes, utils::OptionExt, ComputeIndexes};
+
+impl Vecs {
+    pub fn compute(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        distribution: &distribution::Vecs,
+        exit: &Exit,
+    ) -> Result<()> {
+        let circulating_supply = &distribution.utxo_cohorts.all.metrics.supply.height_to_supply;
+
+        self.indexes_to_coinblocks_created
+            .compute_all(indexes, starting_indexes, exit, |vec| {
+                vec.compute_transform(
+                    starting_indexes.height,
+                    circulating_supply,
+                    |(i, v, ..)| (i, StoredF64::from(Bitcoin::from(v))),
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        let indexes_to_coinblocks_destroyed = &distribution
+            .utxo_cohorts
+            .all
+            .metrics
+            .activity
+            .indexes_to_coinblocks_destroyed;
+
+        self.indexes_to_coinblocks_stored
+            .compute_all(indexes, starting_indexes, exit, |vec| {
+                let mut coinblocks_destroyed_iter = indexes_to_coinblocks_destroyed
+                    .height
+                    .as_ref()
+                    .unwrap()
+                    .into_iter();
+                vec.compute_transform(
+                    starting_indexes.height,
+                    self.indexes_to_coinblocks_created.height.u(),
+                    |(i, created, ..)| {
+                        let destroyed = coinblocks_destroyed_iter.get_unwrap(i);
+                        (i, created.checked_sub(destroyed).unwrap())
+                    },
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_liveliness
+            .compute_all(indexes, starting_indexes, exit, |vec| {
+                vec.compute_divide(
+                    starting_indexes.height,
+                    indexes_to_coinblocks_destroyed
+                        .height_extra
+                        .unwrap_cumulative(),
+                    self.indexes_to_coinblocks_created
+                        .height_extra
+                        .unwrap_cumulative(),
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_vaultedness
+            .compute_all(indexes, starting_indexes, exit, |vec| {
+                vec.compute_transform(
+                    starting_indexes.height,
+                    self.indexes_to_liveliness.height.u(),
+                    |(i, v, ..)| (i, StoredF64::from(1.0).checked_sub(v).unwrap()),
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_activity_to_vaultedness_ratio.compute_all(
+            indexes,
+            starting_indexes,
+            exit,
+            |vec| {
+                vec.compute_divide(
+                    starting_indexes.height,
+                    self.indexes_to_liveliness.height.u(),
+                    self.indexes_to_vaultedness.height.u(),
+                    exit,
+                )?;
+                Ok(())
+            },
+        )?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/cointime/activity/import.rs

@@ -0,0 +1,40 @@
+use brk_error::Result;
+use brk_types::Version;
+use vecdb::Database;
+
+use super::Vecs;
+use crate::{
+    indexes,
+    internal::{ComputedVecsFromHeight, Source, VecBuilderOptions},
+};
+
+impl Vecs {
+    pub fn forced_import(db: &Database, version: Version, indexes: &indexes::Vecs) -> Result<Self> {
+        let last = || VecBuilderOptions::default().add_last();
+        let sum_cum = || VecBuilderOptions::default().add_sum().add_cumulative();
+
+        macro_rules! computed_h {
+            ($name:expr, $opts:expr) => {
+                ComputedVecsFromHeight::forced_import(
+                    db,
+                    $name,
+                    Source::Compute,
+                    version,
+                    indexes,
+                    $opts,
+                )?
+            };
+        }
+
+        Ok(Self {
+            indexes_to_coinblocks_created: computed_h!("coinblocks_created", sum_cum()),
+            indexes_to_coinblocks_stored: computed_h!("coinblocks_stored", sum_cum()),
+            indexes_to_liveliness: computed_h!("liveliness", last()),
+            indexes_to_vaultedness: computed_h!("vaultedness", last()),
+            indexes_to_activity_to_vaultedness_ratio: computed_h!(
+                "activity_to_vaultedness_ratio",
+                last()
+            ),
+        })
+    }
+}

crates/brk_computer/src/cointime/activity/mod.rs

@@ -0,0 +1,5 @@
+mod compute;
+mod import;
+mod vecs;
+
+pub use vecs::Vecs;

crates/brk_computer/src/cointime/activity/vecs.rs

@@ -0,0 +1,13 @@
+use brk_traversable::Traversable;
+use brk_types::StoredF64;
+
+use crate::internal::ComputedVecsFromHeight;
+
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    pub indexes_to_coinblocks_created: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_coinblocks_stored: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_liveliness: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_vaultedness: ComputedVecsFromHeight<StoredF64>,
+    pub indexes_to_activity_to_vaultedness_ratio: ComputedVecsFromHeight<StoredF64>,
+}