global: dca classes

crates/brk_computer/src/vecs/market.rs

@@ -1,6 +1,6 @@
 use std::{fs, path::Path, thread};
 
-use brk_core::{Dollars, Sats, StoredF32, StoredUsize};
+use brk_core::{Date, DateIndex, Dollars, Sats, StoredF32, StoredUsize};
 use brk_exit::Exit;
 use brk_indexer::Indexer;
 use brk_vec::{AnyCollectableVec, Compressed, Computation, StoredIndex, VecIterator, Version};
@@ -13,7 +13,7 @@ use super::{
     indexes, transactions,
 };
 
-const VERSION: Version = Version::new(10);
+const VERSION: Version = Version::new(0);
 
 #[derive(Clone)]
 pub struct Vecs {
@@ -116,6 +116,42 @@ pub struct Vecs {
     pub _6y_dca_cagr: ComputedVecsFromDateIndex<StoredF32>,
     pub _8y_dca_cagr: ComputedVecsFromDateIndex<StoredF32>,
     pub _10y_dca_cagr: ComputedVecsFromDateIndex<StoredF32>,
+
+    pub dca_class_2025_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2024_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2023_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2022_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2021_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2020_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2019_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2018_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2017_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2016_stack: ComputedVecsFromDateIndex<Sats>,
+    pub dca_class_2015_stack: ComputedVecsFromDateIndex<Sats>,
+
+    pub dca_class_2025_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2024_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2023_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2022_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2021_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2020_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2019_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2018_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2017_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2016_avg_price: ComputedVecsFromDateIndex<Dollars>,
+    pub dca_class_2015_avg_price: ComputedVecsFromDateIndex<Dollars>,
+
+    pub dca_class_2025_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2024_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2023_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2022_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2021_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2020_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2019_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2018_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2017_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2016_returns: ComputedVecsFromDateIndex<StoredF32>,
+    pub dca_class_2015_returns: ComputedVecsFromDateIndex<StoredF32>,
 }
 
 impl Vecs {
@@ -795,6 +831,240 @@ impl Vecs {
                 compressed,
                 StorableVecGeneatorOptions::default().add_last(),
             )?,
+
+            dca_class_2025_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2025_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2024_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2024_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2023_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2023_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2022_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2022_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2021_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2021_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2020_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2020_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2019_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2019_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2018_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2018_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2017_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2017_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2016_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2016_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2015_stack: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2015_stack",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+
+            dca_class_2025_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2025_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2024_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2024_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2023_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2023_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2022_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2022_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2021_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2021_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2020_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2020_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2019_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2019_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2018_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2018_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2017_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2017_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2016_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2016_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2015_avg_price: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2015_avg_price",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+
+            dca_class_2025_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2025_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2024_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2024_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2023_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2023_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2022_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2022_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2021_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2021_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2020_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2020_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2019_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2019_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2018_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2018_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2017_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2017_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2016_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2016_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
+            dca_class_2015_returns: ComputedVecsFromDateIndex::forced_import(
+                path,
+                "dca_class_2015_returns",
+                VERSION + Version::ZERO,
+                compressed,
+                StorableVecGeneatorOptions::default().add_last(),
+            )?,
         })
     }
 
@@ -1151,7 +1421,7 @@ impl Vecs {
                     starting_indexes,
                     exit,
                     |v, _, _, starting_indexes, exit| {
-                        v.compute_dca_stack(
+                        v.compute_dca_stack_via_len(
                             starting_indexes.dateindex,
                             &fetched.timeindexes_to_close.dateindex,
                             days,
@@ -1166,7 +1436,7 @@ impl Vecs {
                     starting_indexes,
                     exit,
                     |v, _, _, starting_indexes, exit| {
-                        v.compute_dca_avg_price(
+                        v.compute_dca_avg_price_via_len(
                             starting_indexes.dateindex,
                             &dca_stack.dateindex,
                             days,
@@ -1211,6 +1481,128 @@ impl Vecs {
             },
         )?;
 
+        [
+            (
+                2015,
+                &mut self.dca_class_2015_avg_price,
+                &mut self.dca_class_2015_returns,
+                &mut self.dca_class_2015_stack,
+            ),
+            (
+                2016,
+                &mut self.dca_class_2016_avg_price,
+                &mut self.dca_class_2016_returns,
+                &mut self.dca_class_2016_stack,
+            ),
+            (
+                2017,
+                &mut self.dca_class_2017_avg_price,
+                &mut self.dca_class_2017_returns,
+                &mut self.dca_class_2017_stack,
+            ),
+            (
+                2018,
+                &mut self.dca_class_2018_avg_price,
+                &mut self.dca_class_2018_returns,
+                &mut self.dca_class_2018_stack,
+            ),
+            (
+                2019,
+                &mut self.dca_class_2019_avg_price,
+                &mut self.dca_class_2019_returns,
+                &mut self.dca_class_2019_stack,
+            ),
+            (
+                2020,
+                &mut self.dca_class_2020_avg_price,
+                &mut self.dca_class_2020_returns,
+                &mut self.dca_class_2020_stack,
+            ),
+            (
+                2021,
+                &mut self.dca_class_2021_avg_price,
+                &mut self.dca_class_2021_returns,
+                &mut self.dca_class_2021_stack,
+            ),
+            (
+                2022,
+                &mut self.dca_class_2022_avg_price,
+                &mut self.dca_class_2022_returns,
+                &mut self.dca_class_2022_stack,
+            ),
+            (
+                2023,
+                &mut self.dca_class_2023_avg_price,
+                &mut self.dca_class_2023_returns,
+                &mut self.dca_class_2023_stack,
+            ),
+            (
+                2024,
+                &mut self.dca_class_2024_avg_price,
+                &mut self.dca_class_2024_returns,
+                &mut self.dca_class_2024_stack,
+            ),
+            (
+                2025,
+                &mut self.dca_class_2025_avg_price,
+                &mut self.dca_class_2025_returns,
+                &mut self.dca_class_2025_stack,
+            ),
+        ]
+        .into_iter()
+        .try_for_each(
+            |(year, avg_price, returns, stack)| -> color_eyre::Result<()> {
+                let dateindex = DateIndex::try_from(Date::new(year, 1, 1)).unwrap();
+
+                stack.compute(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |v, _, _, starting_indexes, exit| {
+                        v.compute_dca_stack_via_from(
+                            starting_indexes.dateindex,
+                            &fetched.timeindexes_to_close.dateindex,
+                            dateindex,
+                            exit,
+                        )
+                    },
+                )?;
+
+                avg_price.compute(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |v, _, _, starting_indexes, exit| {
+                        v.compute_dca_avg_price_via_from(
+                            starting_indexes.dateindex,
+                            &stack.dateindex,
+                            dateindex,
+                            exit,
+                        )
+                    },
+                )?;
+
+                returns.compute(
+                    indexer,
+                    indexes,
+                    starting_indexes,
+                    exit,
+                    |v, _, _, starting_indexes, exit| {
+                        v.compute_percentage_difference(
+                            starting_indexes.dateindex,
+                            &fetched.timeindexes_to_close.dateindex,
+                            &avg_price.dateindex,
+                            exit,
+                        )
+                    },
+                )?;
+
+                Ok(())
+            },
+        )?;
+
         thread::scope(|s| -> color_eyre::Result<()> {
             [
                 (&mut self.indexes_to_1w_sma, 7),
@@ -1348,6 +1740,39 @@ impl Vecs {
             self._6y_dca_stack.vecs(),
             self._8y_dca_stack.vecs(),
             self._10y_dca_stack.vecs(),
+            self.dca_class_2025_stack.vecs(),
+            self.dca_class_2024_stack.vecs(),
+            self.dca_class_2023_stack.vecs(),
+            self.dca_class_2022_stack.vecs(),
+            self.dca_class_2021_stack.vecs(),
+            self.dca_class_2020_stack.vecs(),
+            self.dca_class_2019_stack.vecs(),
+            self.dca_class_2018_stack.vecs(),
+            self.dca_class_2017_stack.vecs(),
+            self.dca_class_2016_stack.vecs(),
+            self.dca_class_2015_stack.vecs(),
+            self.dca_class_2025_avg_price.vecs(),
+            self.dca_class_2024_avg_price.vecs(),
+            self.dca_class_2023_avg_price.vecs(),
+            self.dca_class_2022_avg_price.vecs(),
+            self.dca_class_2021_avg_price.vecs(),
+            self.dca_class_2020_avg_price.vecs(),
+            self.dca_class_2019_avg_price.vecs(),
+            self.dca_class_2018_avg_price.vecs(),
+            self.dca_class_2017_avg_price.vecs(),
+            self.dca_class_2016_avg_price.vecs(),
+            self.dca_class_2015_avg_price.vecs(),
+            self.dca_class_2025_returns.vecs(),
+            self.dca_class_2024_returns.vecs(),
+            self.dca_class_2023_returns.vecs(),
+            self.dca_class_2022_returns.vecs(),
+            self.dca_class_2021_returns.vecs(),
+            self.dca_class_2020_returns.vecs(),
+            self.dca_class_2019_returns.vecs(),
+            self.dca_class_2018_returns.vecs(),
+            self.dca_class_2017_returns.vecs(),
+            self.dca_class_2016_returns.vecs(),
+            self.dca_class_2015_returns.vecs(),
         ]
         .concat()
     }

crates/brk_vec/src/variants/eager.rs

@@ -9,7 +9,7 @@ use std::{
 };
 
 use brk_core::{
-    Bitcoin, CheckedSub, Close, DateIndex, Dollars, Height, Sats, StoredUsize, TxIndex,
+    Bitcoin, CheckedSub, Close, Date, DateIndex, Dollars, Height, Sats, StoredUsize, TxIndex,
 };
 use brk_exit::Exit;
 use log::info;
@@ -668,7 +668,7 @@ where
 }
 
 impl EagerVec<DateIndex, Sats> {
-    pub fn compute_dca_stack(
+    pub fn compute_dca_stack_via_len(
         &mut self,
         max_from: DateIndex,
         closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>,
@@ -676,7 +676,7 @@ impl EagerVec<DateIndex, Sats> {
         exit: &Exit,
     ) -> Result<()> {
         self.validate_computed_version_or_reset_file(
-            Version::ZERO + self.inner.version() + closes.version(),
+            Version::new(5) + self.inner.version() + closes.version(),
         )?;
 
         let mut other_iter = closes.iter();
@@ -698,6 +698,7 @@ impl EagerVec<DateIndex, Sats> {
 
             if price != Dollars::ZERO {
                 stack = prev.unwrap() + Sats::from(Bitcoin::from(DCA_AMOUNT / price));
+
                 if i_usize >= len {
                     let prev_price = *other_iter.unwrap_get_inner_(i_usize - len);
                     if prev_price != Dollars::ZERO {
@@ -715,10 +716,49 @@ impl EagerVec<DateIndex, Sats> {
 
         self.safe_flush(exit)
     }
+
+    pub fn compute_dca_stack_via_from(
+        &mut self,
+        max_from: DateIndex,
+        closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>,
+        from: DateIndex,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.validate_computed_version_or_reset_file(
+            Version::ZERO + self.inner.version() + closes.version(),
+        )?;
+
+        let mut prev = None;
+
+        let index = max_from.min(DateIndex::from(self.len()));
+        closes.iter_at(index).try_for_each(|(i, closes)| {
+            let price = *closes.into_inner();
+            let i_usize = i.unwrap_to_usize();
+            if prev.is_none() {
+                if i_usize == 0 {
+                    prev.replace(Sats::ZERO);
+                } else {
+                    prev.replace(self.into_iter().unwrap_get_inner_(i_usize - 1));
+                }
+            }
+
+            let mut stack = Sats::ZERO;
+
+            if price != Dollars::ZERO && i >= from {
+                stack = prev.unwrap() + Sats::from(Bitcoin::from(DCA_AMOUNT / price));
+            }
+
+            prev.replace(stack);
+
+            self.forced_push_at(i, stack, exit)
+        })?;
+
+        self.safe_flush(exit)
+    }
 }
 
 impl EagerVec<DateIndex, Dollars> {
-    pub fn compute_dca_avg_price(
+    pub fn compute_dca_avg_price_via_len(
         &mut self,
         max_from: DateIndex,
         stacks: &impl AnyIterableVec<DateIndex, Sats>,
@@ -726,14 +766,51 @@ impl EagerVec<DateIndex, Dollars> {
         exit: &Exit,
     ) -> Result<()> {
         self.validate_computed_version_or_reset_file(
-            Version::ONE + self.inner.version() + stacks.version(),
+            Version::TWO + self.inner.version() + stacks.version(),
         )?;
 
         let index = max_from.min(DateIndex::from(self.len()));
 
+        let first_price_date = DateIndex::try_from(Date::new(2010, 8, 16)).unwrap();
+
         stacks.iter_at(index).try_for_each(|(i, stack)| {
             let stack = stack.into_inner();
-            let avg_price = DCA_AMOUNT * len.min(i.unwrap_to_usize() + 1) / Bitcoin::from(stack);
+            let mut avg_price = Dollars::from(f64::NAN);
+            if i > first_price_date {
+                avg_price = DCA_AMOUNT
+                    * len
+                        .min(i.unwrap_to_usize() + 1)
+                        .min(i.checked_sub(first_price_date).unwrap().unwrap_to_usize() + 1)
+                    / Bitcoin::from(stack);
+            }
+            self.forced_push_at(i, avg_price, exit)
+        })?;
+
+        self.safe_flush(exit)
+    }
+
+    pub fn compute_dca_avg_price_via_from(
+        &mut self,
+        max_from: DateIndex,
+        stacks: &impl AnyIterableVec<DateIndex, Sats>,
+        from: DateIndex,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.validate_computed_version_or_reset_file(
+            Version::ZERO + self.inner.version() + stacks.version(),
+        )?;
+
+        let index = max_from.min(DateIndex::from(self.len()));
+
+        let from_usize = from.unwrap_to_usize();
+
+        stacks.iter_at(index).try_for_each(|(i, stack)| {
+            let stack = stack.into_inner();
+            let mut avg_price = Dollars::from(f64::NAN);
+            if i >= from {
+                avg_price =
+                    DCA_AMOUNT * (i.unwrap_to_usize() + 1 - from_usize) / Bitcoin::from(stack);
+            }
             self.forced_push_at(i, avg_price, exit)
         })?;
 

websites/kibo.money/scripts/main.js

@@ -1631,6 +1631,23 @@ function createColors(dark, elements) {
     _4y: purple,
     _10y: fuchsia,
 
+    2015: pink,
+    2016: red,
+    2017: orange,
+    2018: amber,
+    2019: yellow,
+    2020: lime,
+    2021: green,
+    2022: emerald,
+    2023: teal,
+    2024: cyan,
+    2025: sky,
+    2026: blue,
+    2027: indigo,
+    2028: violet,
+    2029: purple,
+    2030: fuchsia,
+
     // r1d: pink,
     // r1w: red,
     // r1m: amber,

websites/kibo.money/scripts/vecid-to-indexes.js

@@ -593,6 +593,39 @@ export function createVecIdToIndexes() {
     "dateindex": [DateIndex, Height],
     "dateindex-count": [MonthIndex, WeekIndex],
     "days-since-ath": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2015-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2015-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2015-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2016-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2016-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2016-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2017-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2017-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2017-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2018-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2018-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2018-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2019-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2019-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2019-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2020-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2020-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2020-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2021-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2021-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2021-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2022-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2022-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2022-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2023-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2023-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2023-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2024-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2024-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2024-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2025-avg-price": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2025-returns": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
+    "dca-class-2025-stack": [DateIndex, DecadeIndex, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
     "decadeindex": [DecadeIndex, YearIndex],
     "difficulty": [DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, WeekIndex, YearIndex],
     "difficultyepoch": [DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, WeekIndex, YearIndex],