global: MASSIVE snapshot

crates/brk_computer/src/blocks/difficulty/compute.rs

@@ -0,0 +1,63 @@
+use brk_error::Result;
+use brk_types::StoredU32;
+use vecdb::{Exit, TypedVecIterator};
+
+use super::Vecs;
+use super::super::TARGET_BLOCKS_PER_DAY_F32;
+use crate::{indexes, ComputeIndexes};
+
+impl Vecs {
+    pub fn compute(
+        &mut self,
+        indexes: &indexes::Vecs,
+        starting_indexes: &ComputeIndexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        let mut height_to_difficultyepoch_iter =
+            indexes.block.height_to_difficultyepoch.into_iter();
+        self.indexes_to_difficultyepoch
+            .compute_all(starting_indexes, exit, |vec| {
+                let mut height_count_iter = indexes.time.dateindex_to_height_count.into_iter();
+                vec.compute_transform(
+                    starting_indexes.dateindex,
+                    &indexes.time.dateindex_to_first_height,
+                    |(di, height, ..)| {
+                        (
+                            di,
+                            height_to_difficultyepoch_iter
+                                .get_unwrap(height + (*height_count_iter.get_unwrap(di) - 1)),
+                        )
+                    },
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_blocks_before_next_difficulty_adjustment
+            .compute_all(indexes, starting_indexes, exit, |v| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    &indexes.block.height_to_height,
+                    |(h, ..)| (h, StoredU32::from(h.left_before_next_diff_adj())),
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.indexes_to_days_before_next_difficulty_adjustment
+            .compute_all(indexes, starting_indexes, exit, |v| {
+                v.compute_transform(
+                    starting_indexes.height,
+                    self.indexes_to_blocks_before_next_difficulty_adjustment
+                        .height
+                        .as_ref()
+                        .unwrap(),
+                    |(h, blocks, ..)| (h, (*blocks as f32 / TARGET_BLOCKS_PER_DAY_F32).into()),
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/blocks/difficulty/import.rs

@@ -0,0 +1,46 @@
+use brk_error::Result;
+use brk_types::Version;
+use vecdb::Database;
+
+use super::Vecs;
+use crate::{
+    indexes,
+    internal::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, Source, VecBuilderOptions},
+};
+
+impl Vecs {
+    pub fn forced_import(db: &Database, version: Version, indexes: &indexes::Vecs) -> Result<Self> {
+        let v0 = Version::ZERO;
+        let v2 = Version::TWO;
+        let last = || VecBuilderOptions::default().add_last();
+
+        Ok(Self {
+            indexes_to_difficultyepoch: ComputedVecsFromDateIndex::forced_import(
+                db,
+                "difficultyepoch",
+                Source::Compute,
+                version + v0,
+                indexes,
+                last(),
+            )?,
+            indexes_to_blocks_before_next_difficulty_adjustment:
+                ComputedVecsFromHeight::forced_import(
+                    db,
+                    "blocks_before_next_difficulty_adjustment",
+                    Source::Compute,
+                    version + v2,
+                    indexes,
+                    last(),
+                )?,
+            indexes_to_days_before_next_difficulty_adjustment:
+                ComputedVecsFromHeight::forced_import(
+                    db,
+                    "days_before_next_difficulty_adjustment",
+                    Source::Compute,
+                    version + v2,
+                    indexes,
+                    last(),
+                )?,
+        })
+    }
+}

crates/brk_computer/src/blocks/difficulty/mod.rs

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

crates/brk_computer/src/blocks/difficulty/vecs.rs

@@ -0,0 +1,12 @@
+use brk_traversable::Traversable;
+use brk_types::{DifficultyEpoch, StoredF32, StoredU32};
+
+use crate::internal::{ComputedVecsFromDateIndex, ComputedVecsFromHeight};
+
+/// Difficulty epoch metrics and countdown
+#[derive(Clone, Traversable)]
+pub struct Vecs {
+    pub indexes_to_difficultyepoch: ComputedVecsFromDateIndex<DifficultyEpoch>,
+    pub indexes_to_blocks_before_next_difficulty_adjustment: ComputedVecsFromHeight<StoredU32>,
+    pub indexes_to_days_before_next_difficulty_adjustment: ComputedVecsFromHeight<StoredF32>,
+}