diff --git a/Cargo.lock b/Cargo.lock
index d1956e9a4..33dd9bf03 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -649,9 +649,9 @@ dependencies = [
 
 [[package]]
 name = "bytecount"
-version = "0.6.8"
+version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ce89b21cab1437276d2650d57e971f9d548a2d9037cc231abdc0562b97498ce"
+checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
 
 [[package]]
 name = "byteorder"
@@ -3047,9 +3047,9 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.4"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fdb0c213ca27a9f57ab69ddb290fd80d970922355b83ae380b395d3986b8a2e"
+checksum = "5cc2d9e086a412a451384326f521c8123a99a466b329941a9403696bff9b0da2"
 dependencies = [
  "async-compression",
  "bitflags",
diff --git a/crates/brk_computer/src/vecs/grouped/value_from_txindex.rs b/crates/brk_computer/src/vecs/grouped/value_from_txindex.rs
index 4e3dfd1ea..5b7a7607e 100644
--- a/crates/brk_computer/src/vecs/grouped/value_from_txindex.rs
+++ b/crates/brk_computer/src/vecs/grouped/value_from_txindex.rs
@@ -203,7 +203,11 @@ impl ComputedValueVecsFromTxindex {
         if let Some(dollars) = self.dollars.as_mut() {
             let dollars_txindex = self.dollars_txindex.as_mut().unwrap();
 
-            dollars_txindex.compute_if_necessary(starting_indexes.txindex, exit)?;
+            dollars_txindex.compute_if_necessary(
+                starting_indexes.txindex,
+                &indexer.vecs().txindex_to_txid,
+                exit,
+            )?;
 
             dollars.compute_rest_from_bitcoin(
                 indexer,
diff --git a/crates/brk_computer/src/vecs/indexes.rs b/crates/brk_computer/src/vecs/indexes.rs
index c602ed5de..77526cddf 100644
--- a/crates/brk_computer/src/vecs/indexes.rs
+++ b/crates/brk_computer/src/vecs/indexes.rs
@@ -5,7 +5,7 @@ use brk_core::{
     InputIndex, MonthIndex, OpReturnIndex, OutputIndex, P2ABytes, P2AIndex, P2MSIndex, P2PK33Bytes,
     P2PK33Index, P2PK65Bytes, P2PK65Index, P2PKHBytes, P2PKHIndex, P2SHBytes, P2SHIndex, P2TRBytes,
     P2TRIndex, P2WPKHBytes, P2WPKHIndex, P2WSHBytes, P2WSHIndex, QuarterIndex, Sats, StoredUsize,
-    Timestamp, TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, YearIndex,
+    Timestamp, TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, Weight, YearIndex,
 };
 use brk_exit::Exit;
 use brk_indexer::Indexer;
@@ -44,7 +44,7 @@ pub struct Vecs {
     pub height_to_dateindex: EagerVec<Height, DateIndex>,
     pub height_to_difficultyepoch: ComputedVecFrom1<Height, DifficultyEpoch, Height, Height>,
     pub height_to_halvingepoch: ComputedVecFrom1<Height, HalvingEpoch, Height, Height>,
-    pub height_to_height: ComputedVecFrom1<Height, Height, Height, Date>,
+    pub height_to_height: ComputedVecFrom1<Height, Height, Height, Weight>,
     pub height_to_timestamp_fixed: EagerVec<Height, Timestamp>,
     pub height_to_txindex_count: EagerVec<Height, StoredUsize>,
     pub inputindex_to_inputindex: ComputedVecFrom1<InputIndex, InputIndex, InputIndex, OutputIndex>,
@@ -322,7 +322,7 @@ impl Vecs {
             "height",
             version + VERSION + Version::ZERO,
             format,
-            height_to_date.boxed_clone(),
+            indexer.vecs().height_to_weight.boxed_clone(),
             |index, _| Some(index),
         )?;
 
@@ -642,8 +642,17 @@ impl Vecs {
         // OutputIndex
         // ---
 
-        self.outputindex_to_outputindex
-            .compute_if_necessary(starting_indexes.outputindex, exit)?;
+        self.outputindex_to_outputindex.compute_if_necessary(
+            starting_indexes.outputindex,
+            &indexer_vecs.outputindex_to_value,
+            exit,
+        )?;
+
+        self.txindex_to_output_count.compute_if_necessary(
+            starting_indexes.txindex,
+            &indexer_vecs.txindex_to_txid,
+            exit,
+        )?;
 
         self.outputindex_to_txindex.compute_inverse_less_to_more(
             starting_indexes.txindex,
@@ -652,55 +661,99 @@ impl Vecs {
             exit,
         )?;
 
-        self.p2pk33index_to_p2pk33index
-            .compute_if_necessary(starting_indexes.p2pk33index, exit)?;
+        self.p2pk33index_to_p2pk33index.compute_if_necessary(
+            starting_indexes.p2pk33index,
+            &indexer_vecs.p2pk33index_to_p2pk33bytes,
+            exit,
+        )?;
 
-        self.p2pk65index_to_p2pk65index
-            .compute_if_necessary(starting_indexes.p2pk65index, exit)?;
+        self.p2pk65index_to_p2pk65index.compute_if_necessary(
+            starting_indexes.p2pk65index,
+            &indexer_vecs.p2pk65index_to_p2pk65bytes,
+            exit,
+        )?;
 
-        self.p2pkhindex_to_p2pkhindex
-            .compute_if_necessary(starting_indexes.p2pkhindex, exit)?;
+        self.p2pkhindex_to_p2pkhindex.compute_if_necessary(
+            starting_indexes.p2pkhindex,
+            &indexer_vecs.p2pkhindex_to_p2pkhbytes,
+            exit,
+        )?;
 
-        self.p2shindex_to_p2shindex
-            .compute_if_necessary(starting_indexes.p2shindex, exit)?;
+        self.p2shindex_to_p2shindex.compute_if_necessary(
+            starting_indexes.p2shindex,
+            &indexer_vecs.p2shindex_to_p2shbytes,
+            exit,
+        )?;
 
-        self.p2trindex_to_p2trindex
-            .compute_if_necessary(starting_indexes.p2trindex, exit)?;
+        self.p2trindex_to_p2trindex.compute_if_necessary(
+            starting_indexes.p2trindex,
+            &indexer_vecs.p2trindex_to_p2trbytes,
+            exit,
+        )?;
 
-        self.p2wpkhindex_to_p2wpkhindex
-            .compute_if_necessary(starting_indexes.p2wpkhindex, exit)?;
+        self.p2wpkhindex_to_p2wpkhindex.compute_if_necessary(
+            starting_indexes.p2wpkhindex,
+            &indexer_vecs.p2wpkhindex_to_p2wpkhbytes,
+            exit,
+        )?;
 
-        self.p2wshindex_to_p2wshindex
-            .compute_if_necessary(starting_indexes.p2wshindex, exit)?;
+        self.p2wshindex_to_p2wshindex.compute_if_necessary(
+            starting_indexes.p2wshindex,
+            &indexer_vecs.p2wshindex_to_p2wshbytes,
+            exit,
+        )?;
 
         self.emptyoutputindex_to_emptyoutputindex
-            .compute_if_necessary(starting_indexes.emptyoutputindex, exit)?;
+            .compute_if_necessary(
+                starting_indexes.emptyoutputindex,
+                &indexer_vecs.emptyoutputindex_to_txindex,
+                exit,
+            )?;
 
-        self.p2msindex_to_p2msindex
-            .compute_if_necessary(starting_indexes.p2msindex, exit)?;
+        self.p2msindex_to_p2msindex.compute_if_necessary(
+            starting_indexes.p2msindex,
+            &indexer_vecs.p2msindex_to_txindex,
+            exit,
+        )?;
 
-        self.opreturnindex_to_opreturnindex
-            .compute_if_necessary(starting_indexes.opreturnindex, exit)?;
+        self.opreturnindex_to_opreturnindex.compute_if_necessary(
+            starting_indexes.opreturnindex,
+            &indexer_vecs.opreturnindex_to_txindex,
+            exit,
+        )?;
 
-        self.p2aindex_to_p2aindex
-            .compute_if_necessary(starting_indexes.p2aindex, exit)?;
+        self.p2aindex_to_p2aindex.compute_if_necessary(
+            starting_indexes.p2aindex,
+            &indexer_vecs.p2aindex_to_p2abytes,
+            exit,
+        )?;
 
         self.unknownoutputindex_to_unknownoutputindex
-            .compute_if_necessary(starting_indexes.unknownoutputindex, exit)?;
+            .compute_if_necessary(
+                starting_indexes.unknownoutputindex,
+                &indexer_vecs.unknownoutputindex_to_txindex,
+                exit,
+            )?;
 
         // ---
         // InputIndex
         // ---
 
-        self.inputindex_to_inputindex
-            .compute_if_necessary(starting_indexes.inputindex, exit)?;
+        self.inputindex_to_inputindex.compute_if_necessary(
+            starting_indexes.inputindex,
+            &indexer_vecs.inputindex_to_outputindex,
+            exit,
+        )?;
 
         // ---
         // TxIndex
         // ---
 
-        self.txindex_to_txindex
-            .compute_if_necessary(starting_indexes.txindex, exit)?;
+        self.txindex_to_txindex.compute_if_necessary(
+            starting_indexes.txindex,
+            &indexer_vecs.txindex_to_txid,
+            exit,
+        )?;
 
         self.height_to_txindex_count.compute_count_from_indexes(
             starting_indexes.height,
@@ -720,8 +773,11 @@ impl Vecs {
         // Height
         // ---
 
-        self.height_to_height
-            .compute_if_necessary(starting_indexes.height, exit)?;
+        self.height_to_height.compute_if_necessary(
+            starting_indexes.height,
+            &indexer_vecs.height_to_weight,
+            exit,
+        )?;
 
         self.height_to_date.compute_transform(
             starting_indexes.height,
@@ -795,11 +851,17 @@ impl Vecs {
                 exit,
             )?;
 
-        self.dateindex_to_dateindex
-            .compute_if_necessary(starting_dateindex, exit)?;
+        self.dateindex_to_dateindex.compute_if_necessary(
+            starting_dateindex,
+            &self.dateindex_to_first_height,
+            exit,
+        )?;
 
-        self.dateindex_to_date
-            .compute_if_necessary(starting_dateindex, exit)?;
+        self.dateindex_to_date.compute_if_necessary(
+            starting_dateindex,
+            &self.dateindex_to_first_height,
+            exit,
+        )?;
 
         self.dateindex_to_height_count.compute_count_from_indexes(
             starting_dateindex,
@@ -828,8 +890,11 @@ impl Vecs {
         self.weekindex_to_first_dateindex
             .compute_inverse_more_to_less(starting_dateindex, &self.dateindex_to_weekindex, exit)?;
 
-        self.weekindex_to_weekindex
-            .compute_if_necessary(starting_weekindex, exit)?;
+        self.weekindex_to_weekindex.compute_if_necessary(
+            starting_weekindex,
+            &self.weekindex_to_first_dateindex,
+            exit,
+        )?;
 
         self.weekindex_to_dateindex_count
             .compute_count_from_indexes(
@@ -849,8 +914,11 @@ impl Vecs {
             .get_inner(decremented_starting_height)
             .unwrap_or_default();
 
-        self.height_to_difficultyepoch
-            .compute_if_necessary(starting_indexes.height, exit)?;
+        self.height_to_difficultyepoch.compute_if_necessary(
+            starting_indexes.height,
+            &indexer_vecs.height_to_weight,
+            exit,
+        )?;
 
         self.difficultyepoch_to_first_height
             .compute_inverse_more_to_less(
@@ -860,7 +928,11 @@ impl Vecs {
             )?;
 
         self.difficultyepoch_to_difficultyepoch
-            .compute_if_necessary(starting_difficultyepoch, exit)?;
+            .compute_if_necessary(
+                starting_difficultyepoch,
+                &self.difficultyepoch_to_first_height,
+                exit,
+            )?;
 
         self.difficultyepoch_to_height_count
             .compute_count_from_indexes(
@@ -894,8 +966,11 @@ impl Vecs {
                 exit,
             )?;
 
-        self.monthindex_to_monthindex
-            .compute_if_necessary(starting_monthindex, exit)?;
+        self.monthindex_to_monthindex.compute_if_necessary(
+            starting_monthindex,
+            &self.monthindex_to_first_dateindex,
+            exit,
+        )?;
 
         self.monthindex_to_dateindex_count
             .compute_count_from_indexes(
@@ -915,8 +990,11 @@ impl Vecs {
             .get_inner(starting_monthindex)
             .unwrap_or_default();
 
-        self.monthindex_to_quarterindex
-            .compute_if_necessary(starting_monthindex, exit)?;
+        self.monthindex_to_quarterindex.compute_if_necessary(
+            starting_monthindex,
+            &self.monthindex_to_first_dateindex,
+            exit,
+        )?;
 
         self.quarterindex_to_first_monthindex
             .compute_inverse_more_to_less(
@@ -927,8 +1005,11 @@ impl Vecs {
 
         // let quarter_count = self.quarterindex_to_first_monthindex.len();
 
-        self.quarterindex_to_quarterindex
-            .compute_if_necessary(starting_quarterindex, exit)?;
+        self.quarterindex_to_quarterindex.compute_if_necessary(
+            starting_quarterindex,
+            &self.quarterindex_to_first_monthindex,
+            exit,
+        )?;
 
         self.quarterindex_to_monthindex_count
             .compute_count_from_indexes(
@@ -948,8 +1029,11 @@ impl Vecs {
             .get_inner(starting_monthindex)
             .unwrap_or_default();
 
-        self.monthindex_to_yearindex
-            .compute_if_necessary(starting_monthindex, exit)?;
+        self.monthindex_to_yearindex.compute_if_necessary(
+            starting_monthindex,
+            &self.monthindex_to_first_dateindex,
+            exit,
+        )?;
 
         self.yearindex_to_first_monthindex
             .compute_inverse_more_to_less(
@@ -958,8 +1042,11 @@ impl Vecs {
                 exit,
             )?;
 
-        self.yearindex_to_yearindex
-            .compute_if_necessary(starting_yearindex, exit)?;
+        self.yearindex_to_yearindex.compute_if_necessary(
+            starting_yearindex,
+            &self.yearindex_to_first_monthindex,
+            exit,
+        )?;
 
         self.yearindex_to_monthindex_count
             .compute_count_from_indexes(
@@ -978,8 +1065,11 @@ impl Vecs {
             .get_inner(decremented_starting_height)
             .unwrap_or_default();
 
-        self.height_to_halvingepoch
-            .compute_if_necessary(starting_indexes.height, exit)?;
+        self.height_to_halvingepoch.compute_if_necessary(
+            starting_indexes.height,
+            &indexer_vecs.height_to_weight,
+            exit,
+        )?;
 
         self.halvingepoch_to_first_height
             .compute_inverse_more_to_less(
@@ -988,8 +1078,11 @@ impl Vecs {
                 exit,
             )?;
 
-        self.halvingepoch_to_halvingepoch
-            .compute_if_necessary(starting_halvingepoch, exit)?;
+        self.halvingepoch_to_halvingepoch.compute_if_necessary(
+            starting_halvingepoch,
+            &self.halvingepoch_to_first_height,
+            exit,
+        )?;
 
         // ---
         // DecadeIndex
@@ -1001,8 +1094,11 @@ impl Vecs {
             .get_inner(starting_yearindex)
             .unwrap_or_default();
 
-        self.yearindex_to_decadeindex
-            .compute_if_necessary(starting_yearindex, exit)?;
+        self.yearindex_to_decadeindex.compute_if_necessary(
+            starting_yearindex,
+            &self.yearindex_to_first_monthindex,
+            exit,
+        )?;
 
         self.decadeindex_to_first_yearindex
             .compute_inverse_more_to_less(
@@ -1011,8 +1107,11 @@ impl Vecs {
                 exit,
             )?;
 
-        self.decadeindex_to_decadeindex
-            .compute_if_necessary(starting_decadeindex, exit)?;
+        self.decadeindex_to_decadeindex.compute_if_necessary(
+            starting_decadeindex,
+            &self.decadeindex_to_first_yearindex,
+            exit,
+        )?;
 
         self.decadeindex_to_yearindex_count
             .compute_count_from_indexes(
diff --git a/crates/brk_computer/src/vecs/stateful/cohort.rs b/crates/brk_computer/src/vecs/stateful/cohort.rs
index fa093d29a..cf8c72ed0 100644
--- a/crates/brk_computer/src/vecs/stateful/cohort.rs
+++ b/crates/brk_computer/src/vecs/stateful/cohort.rs
@@ -81,6 +81,8 @@ pub struct Vecs {
         Option<EagerVec<Height, Dollars>>,
     pub indexes_to_net_unrealized_profit_and_loss_relative_to_market_cap:
         Option<ComputedVecsFromDateIndex<Dollars>>,
+    // pub indexes_to_net_realized_profit_and_loss_relative_to_realized_cap:
+    // Option<ComputedVecsFromHeight<Dollars>>,
 }
 
 impl Vecs {
diff --git a/crates/brk_computer/src/vecs/transactions.rs b/crates/brk_computer/src/vecs/transactions.rs
index f753246ab..2e050064d 100644
--- a/crates/brk_computer/src/vecs/transactions.rs
+++ b/crates/brk_computer/src/vecs/transactions.rs
@@ -737,20 +737,35 @@ impl Vecs {
         compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v2, TxVersion::TWO)?;
         compute_indexes_to_tx_vany(&mut self.indexes_to_tx_v3, TxVersion::THREE)?;
 
-        self.txindex_to_is_coinbase
-            .compute_if_necessary(starting_indexes.txindex, exit)?;
+        self.txindex_to_is_coinbase.compute_if_necessary(
+            starting_indexes.txindex,
+            &indexer.vecs().txindex_to_txid,
+            exit,
+        )?;
 
-        self.txindex_to_weight
-            .compute_if_necessary(starting_indexes.txindex, exit)?;
+        self.txindex_to_weight.compute_if_necessary(
+            starting_indexes.txindex,
+            &indexer.vecs().txindex_to_txid,
+            exit,
+        )?;
 
-        self.txindex_to_vsize
-            .compute_if_necessary(starting_indexes.txindex, exit)?;
+        self.txindex_to_vsize.compute_if_necessary(
+            starting_indexes.txindex,
+            &indexer.vecs().txindex_to_txid,
+            exit,
+        )?;
 
-        self.inputindex_to_value
-            .compute_if_necessary(starting_indexes.inputindex, exit)?;
+        self.inputindex_to_value.compute_if_necessary(
+            starting_indexes.inputindex,
+            &indexer.vecs().inputindex_to_outputindex,
+            exit,
+        )?;
 
-        self.txindex_to_output_value
-            .compute_if_necessary(starting_indexes.txindex, exit)?;
+        self.txindex_to_output_value.compute_if_necessary(
+            starting_indexes.txindex,
+            &indexer.vecs().txindex_to_txid,
+            exit,
+        )?;
 
         // self.indexes_to_output_value.compute_all(
         //     indexer,
@@ -768,8 +783,11 @@ impl Vecs {
         //     },
         // )?;
 
-        self.txindex_to_input_value
-            .compute_if_necessary(starting_indexes.txindex, exit)?;
+        self.txindex_to_input_value.compute_if_necessary(
+            starting_indexes.txindex,
+            &indexer.vecs().txindex_to_txid,
+            exit,
+        )?;
 
         // self.indexes_to_input_value.compute_all(
         //     indexer,
diff --git a/crates/brk_server/Cargo.toml b/crates/brk_server/Cargo.toml
index 3196206ce..a2521dd95 100644
--- a/crates/brk_server/Cargo.toml
+++ b/crates/brk_server/Cargo.toml
@@ -27,7 +27,7 @@ minreq = { workspace = true }
 oxc = { version = "0.72.2", features = ["codegen", "minifier"] }
 serde = { workspace = true }
 tokio = { workspace = true }
-tower-http = { version = "0.6.4", features = ["compression-full", "trace"] }
+tower-http = { version = "0.6.5", features = ["compression-full", "trace"] }
 zip = "4.0.0"
 tracing = "0.1.41"
 
diff --git a/crates/brk_vec/src/variants/computed.rs b/crates/brk_vec/src/variants/computed.rs
index 0859a33c4..a47ea3b48 100644
--- a/crates/brk_vec/src/variants/computed.rs
+++ b/crates/brk_vec/src/variants/computed.rs
@@ -153,7 +153,12 @@ where
         })
     }
 
-    pub fn compute_if_necessary(&mut self, max_from: I, exit: &Exit) -> Result<()> {
+    pub fn compute_if_necessary<T2>(
+        &mut self,
+        max_from: I,
+        len_source: &impl AnyIterableVec<I, T2>,
+        exit: &Exit,
+    ) -> Result<()> {
         let (vec, dependencies) = if let ComputedVec::Eager {
             vec,
             deps: dependencies,
@@ -164,12 +169,14 @@ where
             return Ok(());
         };
 
+        let len = len_source.len();
+
         match dependencies {
             Dependencies::From1(source, compute) => {
                 let version = source.version();
                 let mut iter = source.iter();
                 let t = |i: I| compute(i, &mut *iter).map(|v| (i, v)).unwrap();
-                vec.compute_to(max_from, 1, version, t, exit)
+                vec.compute_to(max_from, len, version, t, exit)
             }
             Dependencies::From2((source1, source2), compute) => {
                 let version = source1.version() + source2.version();
@@ -180,7 +187,7 @@ where
                         .map(|v| (i, v))
                         .unwrap()
                 };
-                vec.compute_to(max_from, 1, version, t, exit)
+                vec.compute_to(max_from, len, version, t, exit)
             }
             Dependencies::From3((source1, source2, source3), compute) => {
                 let version = source1.version() + source2.version() + source3.version();
@@ -192,7 +199,7 @@ where
                         .map(|v| (i, v))
                         .unwrap()
                 };
-                vec.compute_to(max_from, 1, version, t, exit)
+                vec.compute_to(max_from, len, version, t, exit)
             }
         }
     }
diff --git a/websites/kibo.money/scripts/main.js b/websites/kibo.money/scripts/main.js
index 9bfd67712..2b0179a7a 100644
--- a/websites/kibo.money/scripts/main.js
+++ b/websites/kibo.money/scripts/main.js
@@ -883,6 +883,14 @@ function createUtils() {
       if (unit) throw Error(`Unit "${unit}" already assigned "${id}"`);
       unit = "Hash";
     }
+    if ((!unit || thoroughUnitCheck) && id.includes("days-between")) {
+      if (unit) throw Error(`Unit "${unit}" already assigned "${id}"`);
+      unit = "Days";
+    }
+    if ((!unit || thoroughUnitCheck) && id.includes("years-between")) {
+      if (unit) throw Error(`Unit "${unit}" already assigned "${id}"`);
+      unit = "Years";
+    }
     if (
       (!unit || thoroughUnitCheck) &&
       (id === "0" || id === "1" || id === "50" || id === "100")