crates: snapshot

crates/brk_computer/src/cointime.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 use brk_error::Result;
 use brk_traversable::Traversable;
 use brk_types::{Bitcoin, CheckedSub, Dollars, StoredF32, StoredF64, Version};
-use vecdb::{Database, Exit, IterableCloneableVec, PAGE_SIZE, TypedVecIterator};
+use vecdb::{Database, Exit, PAGE_SIZE, TypedVecIterator};
 
 use crate::{grouped::ComputedVecsFromDateIndex, utils::OptionExt};
 
@@ -107,7 +107,7 @@ impl Vecs {
                 ComputedRatioVecsFromDateIndex::forced_import(
                     &db,
                     $name,
-                    Source::Vec($source.dateindex.unwrap_last().boxed_clone()),
+                    Some($source),
                     v0,
                     indexes,
                     true,

crates/brk_computer/src/grouped/lazy2_from_dateindex.rs

@@ -5,7 +5,7 @@ use brk_types::{
 use schemars::JsonSchema;
 use vecdb::{AnyExportableVec, BinaryTransform, IterableCloneableVec, LazyVecFrom2};
 
-use super::{ComputedVecValue, ComputedVecsFromDateIndex, LazyTransform2Builder};
+use super::{ComputedVecValue, ComputedVecsFromDateIndex, ComputedVecsFromHeight, LazyTransform2Builder};
 
 const VERSION: Version = Version::ZERO;
 
@@ -87,6 +87,64 @@ where
             ),
         }
     }
+
+    /// Create from a `ComputedVecsFromHeight` (first source) and `ComputedVecsFromDateIndex` (second source).
+    /// Used for computing USD values from price (Height-based) and ratio (DateIndex-based).
+    pub fn from_height_and_dateindex<F: BinaryTransform<S1T, S2T, T>>(
+        name: &str,
+        version: Version,
+        source1: &ComputedVecsFromHeight<S1T>,
+        source2: &ComputedVecsFromDateIndex<S2T>,
+    ) -> Self {
+        let v = version + VERSION;
+
+        Self {
+            dateindex: source2.dateindex.as_ref().map(|s2| {
+                LazyVecFrom2::transformed::<F>(
+                    name,
+                    v,
+                    source1.dateindex.unwrap_last().boxed_clone(),
+                    s2.boxed_clone(),
+                )
+            }),
+            weekindex: LazyTransform2Builder::from_lazy::<F, _, _, _, _>(
+                name,
+                v,
+                &source1.weekindex,
+                &source2.weekindex,
+            ),
+            monthindex: LazyTransform2Builder::from_lazy::<F, _, _, _, _>(
+                name,
+                v,
+                &source1.monthindex,
+                &source2.monthindex,
+            ),
+            quarterindex: LazyTransform2Builder::from_lazy::<F, _, _, _, _>(
+                name,
+                v,
+                &source1.quarterindex,
+                &source2.quarterindex,
+            ),
+            semesterindex: LazyTransform2Builder::from_lazy::<F, _, _, _, _>(
+                name,
+                v,
+                &source1.semesterindex,
+                &source2.semesterindex,
+            ),
+            yearindex: LazyTransform2Builder::from_lazy::<F, _, _, _, _>(
+                name,
+                v,
+                &source1.yearindex,
+                &source2.yearindex,
+            ),
+            decadeindex: LazyTransform2Builder::from_lazy::<F, _, _, _, _>(
+                name,
+                v,
+                &source1.decadeindex,
+                &source2.decadeindex,
+            ),
+        }
+    }
 }
 
 impl<T, S1T, S2T> Traversable for LazyVecsFrom2FromDateIndex<T, S1T, S2T>

crates/brk_computer/src/grouped/ratio_from_dateindex.rs

@@ -16,7 +16,7 @@ use crate::{
     utils::{OptionExt, get_percentile},
 };
 
-use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
+use super::{ComputedVecsFromDateIndex, ComputedVecsFromHeight, VecBuilderOptions};
 
 #[derive(Clone, Traversable)]
 pub struct ComputedRatioVecsFromDateIndex {
@@ -51,7 +51,7 @@ impl ComputedRatioVecsFromDateIndex {
     pub fn forced_import(
         db: &Database,
         name: &str,
-        source: Source<DateIndex, Dollars>,
+        metric_price: Option<&ComputedVecsFromHeight<Dollars>>,
         version: Version,
         indexes: &indexes::Vecs,
         extended: bool,
@@ -73,8 +73,9 @@ impl ComputedRatioVecsFromDateIndex {
                 .unwrap()
             };
         }
-        // Create sources first so lazy vecs can reference them
-        let price = source.is_compute().then(|| {
+        // Create price sources first so lazy vecs can reference them
+        // Only compute internally when metric_price is None
+        let price = metric_price.is_none().then(|| {
             ComputedVecsFromDateIndex::forced_import(db, name, Source::Compute, v, indexes, opts)
                 .unwrap()
         });
@@ -103,16 +104,29 @@ impl ComputedRatioVecsFromDateIndex {
         let ratio_pct1 = extended.then(|| import!("ratio_pct1"));
 
         // Create lazy usd vecs from price and ratio sources
+        // Use from_height_and_dateindex when metric_price is provided (external price source)
+        // Use from_computed when price is computed internally
         macro_rules! lazy_usd {
             ($ratio:expr, $suffix:expr) => {
-                price.as_ref().zip($ratio.as_ref()).map(|(p, r)| {
-                    LazyVecsFrom2FromDateIndex::from_computed::<PriceTimesRatio>(
-                        &format!("{name}_{}", $suffix),
-                        v,
-                        p,
-                        r,
-                    )
-                })
+                if let Some(mp) = metric_price {
+                    $ratio.as_ref().map(|r| {
+                        LazyVecsFrom2FromDateIndex::from_height_and_dateindex::<PriceTimesRatio>(
+                            &format!("{name}_{}", $suffix),
+                            v,
+                            mp,
+                            r,
+                        )
+                    })
+                } else {
+                    price.as_ref().zip($ratio.as_ref()).map(|(p, r)| {
+                        LazyVecsFrom2FromDateIndex::from_computed::<PriceTimesRatio>(
+                            &format!("{name}_{}", $suffix),
+                            v,
+                            p,
+                            r,
+                        )
+                    })
+                }
             };
         }
 

crates/brk_computer/src/market/import.rs

@@ -61,7 +61,7 @@ impl Vecs {
                 ComputedRatioVecsFromDateIndex::forced_import(
                     &db,
                     $name,
-                    Source::Compute,
+                    None,
                     version + v0,
                     indexes,
                     true,

crates/brk_computer/src/stateful/compute/mod.rs

@@ -14,7 +14,7 @@ pub use readers::{
 pub use recover::{StartMode, determine_start_mode, recover_state, reset_state};
 
 /// Flush checkpoint interval (every N blocks).
-pub const FLUSH_INTERVAL: usize = 20_000;
+pub const FLUSH_INTERVAL: usize = 10_000;
 
 // BIP30 duplicate coinbase heights (special case handling)
 pub const BIP30_DUPLICATE_HEIGHT_1: u32 = 91_842;

crates/brk_computer/src/stateful/metrics/realized.rs

@@ -249,12 +249,7 @@ impl RealizedMetrics {
             indexes_to_realized_price_extra: ComputedRatioVecsFromDateIndex::forced_import(
                 cfg.db,
                 &cfg.name("realized_price"),
-                Source::Vec(
-                    indexes_to_realized_price
-                        .dateindex
-                        .unwrap_last()
-                        .boxed_clone(),
-                ),
+                Some(&indexes_to_realized_price),
                 cfg.version + v0,
                 cfg.indexes,
                 extended,

crates/brk_computer/src/txins.rs

@@ -12,7 +12,7 @@ use vecdb::{
 
 use super::Indexes;
 
-const BATCH_SIZE: usize = 3 * 1024 * 1024 * 1024 / size_of::<Entry>();
+const BATCH_SIZE: usize = 2 * 1024 * 1024 * 1024 / size_of::<Entry>();
 pub const DB_NAME: &str = "txins";
 
 #[derive(Clone, Traversable)]

crates/brk_computer/src/txouts.rs

@@ -13,6 +13,7 @@ use vecdb::{
 use super::{Indexes, txins};
 
 pub const DB_NAME: &str = "txouts";
+const HEIGHT_BATCH: u32 = 10_000;
 
 #[derive(Clone, Traversable)]
 pub struct Vecs {
@@ -101,7 +102,6 @@ impl Vecs {
             starting_indexes.height
         );
 
-        const HEIGHT_BATCH: u32 = 20_000;
         let mut pairs: Vec<(TxOutIndex, TxInIndex)> = Vec::new();
 
         let mut batch_start_height = min_height;