global: snapshot

crates/brk_computer/src/distribution/cohorts/utxo/groups.rs

@@ -528,7 +528,6 @@ impl UTXOCohorts<Rw> {
                         blocks,
                         prices,
                         starting_indexes,
-                        height_to_market_cap,
                         ss,
                         exit,
                     )
@@ -540,7 +539,6 @@ impl UTXOCohorts<Rw> {
                         blocks,
                         prices,
                         starting_indexes,
-                        height_to_market_cap,
                         ss,
                         exit,
                     )
@@ -557,7 +555,6 @@ impl UTXOCohorts<Rw> {
                         blocks,
                         prices,
                         starting_indexes,
-                        height_to_market_cap,
                         ss,
                         exit,
                     )
@@ -569,7 +566,6 @@ impl UTXOCohorts<Rw> {
                         blocks,
                         prices,
                         starting_indexes,
-                        height_to_market_cap,
                         ss,
                         exit,
                     )

crates/brk_computer/src/distribution/metrics/cohort/core.rs

@@ -1,7 +1,7 @@
 use brk_cohort::Filter;
 use brk_error::Result;
 use brk_traversable::Traversable;
-use brk_types::{Dollars, Height, Indexes, Sats, Version};
+use brk_types::{Height, Indexes, Sats, Version};
 use vecdb::{AnyStoredVec, Exit, ReadableVec, Rw, StorageMode};
 
 use crate::{blocks, prices};
@@ -133,7 +133,6 @@ impl CoreCohortMetrics {
         blocks: &blocks::Vecs,
         prices: &prices::Vecs,
         starting_indexes: &Indexes,
-        height_to_market_cap: &impl ReadableVec<Height, Dollars>,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         exit: &Exit,
     ) -> Result<()> {
@@ -149,7 +148,6 @@ impl CoreCohortMetrics {
             starting_indexes.height,
             &self.unrealized,
             &self.supply.total.sats.height,
-            height_to_market_cap,
             all_supply_sats,
             exit,
         )?;

crates/brk_computer/src/distribution/metrics/realized/base.rs

@@ -1,9 +1,6 @@
 use brk_error::Result;
 use brk_traversable::Traversable;
-use brk_types::{
-    BasisPoints32, BasisPointsSigned32, Bitcoin, Cents, CentsSigned, Dollars, Height, Indexes,
-    StoredF64, Version,
-};
+use brk_types::{Bitcoin, Cents, CentsSigned, Dollars, Height, Indexes, StoredF64, Version};
 use derive_more::{Deref, DerefMut};
 use vecdb::{
     AnyStoredVec, AnyVec, Exit, ReadableCloneableVec, ReadableVec, Rw, StorageMode, WritableVec,
@@ -15,8 +12,8 @@ use crate::{
     internal::{
         ComputedFromHeight, ComputedFromHeightCumulative,
         ComputedFromHeightRatioPercentiles, FiatFromHeight,
-        LazyFromHeight, NegCentsUnsignedToDollars, PercentFromHeight, RatioCents64,
-        RatioCentsBp32, RatioCentsSignedCentsBps32, RollingWindows, ValueFromHeightCumulative,
+        LazyFromHeight, NegCentsUnsignedToDollars, RatioCents64,
+        RollingWindows, ValueFromHeightCumulative,
     },
     prices,
 };
@@ -38,10 +35,6 @@ pub struct RealizedBase<M: StorageMode = Rw> {
     pub net_realized_pnl: ComputedFromHeightCumulative<CentsSigned, M>,
     pub gross_pnl: FiatFromHeight<Cents, M>,
 
-    pub realized_profit_rel_to_realized_cap: PercentFromHeight<BasisPoints32, M>,
-    pub realized_loss_rel_to_realized_cap: PercentFromHeight<BasisPoints32, M>,
-    pub net_realized_pnl_rel_to_realized_cap: PercentFromHeight<BasisPointsSigned32, M>,
-
     pub value_created: ComputedFromHeight<Cents, M>,
     pub value_destroyed: ComputedFromHeight<Cents, M>,
     pub value_created_sum: RollingWindows<Cents, M>,
@@ -71,13 +64,6 @@ impl RealizedBase {
         let net_realized_pnl = cfg.import("net_realized_pnl", v0)?;
         let gross_pnl = cfg.import("realized_gross_pnl", v0)?;
 
-        let realized_profit_rel_to_realized_cap =
-            cfg.import("realized_profit_rel_to_realized_cap", Version::new(2))?;
-        let realized_loss_rel_to_realized_cap =
-            cfg.import("realized_loss_rel_to_realized_cap", Version::new(2))?;
-        let net_realized_pnl_rel_to_realized_cap =
-            cfg.import("net_realized_pnl_rel_to_realized_cap", Version::new(2))?;
-
         let value_created = cfg.import("value_created", v0)?;
         let value_destroyed = cfg.import("value_destroyed", v0)?;
         let value_created_sum = cfg.import("value_created", v1)?;
@@ -98,9 +84,6 @@ impl RealizedBase {
             neg_realized_loss,
             net_realized_pnl,
             gross_pnl,
-            realized_profit_rel_to_realized_cap,
-            realized_loss_rel_to_realized_cap,
-            net_realized_pnl_rel_to_realized_cap,
             value_created,
             value_destroyed,
             value_created_sum,
@@ -221,28 +204,6 @@ impl RealizedBase {
             exit,
         )?;
 
-        self.realized_profit_rel_to_realized_cap
-            .compute_binary::<Cents, Cents, RatioCentsBp32>(
-                starting_indexes.height,
-                &self.minimal.realized_profit.height,
-                &self.minimal.realized_cap_cents.height,
-                exit,
-            )?;
-        self.realized_loss_rel_to_realized_cap
-            .compute_binary::<Cents, Cents, RatioCentsBp32>(
-                starting_indexes.height,
-                &self.minimal.realized_loss.height,
-                &self.minimal.realized_cap_cents.height,
-                exit,
-            )?;
-        self.net_realized_pnl_rel_to_realized_cap
-            .compute_binary::<CentsSigned, Cents, RatioCentsSignedCentsBps32>(
-                starting_indexes.height,
-                &self.net_realized_pnl.height,
-                &self.minimal.realized_cap_cents.height,
-                exit,
-            )?;
-
         // SOPR: rolling sums of stateful value_created/destroyed, then ratio, then EMAs
         let window_starts = blocks.count.window_starts();
         self.value_created_sum.compute_rolling_sum(

crates/brk_computer/src/distribution/metrics/realized/full.rs

@@ -35,6 +35,10 @@ pub struct RealizedFull<M: StorageMode = Rw> {
     #[traversable(flatten)]
     pub core: RealizedBase<M>,
 
+    pub realized_profit_rel_to_realized_cap: PercentFromHeight<BasisPoints32, M>,
+    pub realized_loss_rel_to_realized_cap: PercentFromHeight<BasisPoints32, M>,
+    pub net_realized_pnl_rel_to_realized_cap: PercentFromHeight<BasisPointsSigned32, M>,
+
     pub profit_value_created: ComputedFromHeight<Cents, M>,
     pub profit_value_destroyed: ComputedFromHeight<Cents, M>,
     pub loss_value_created: ComputedFromHeight<Cents, M>,
@@ -134,6 +138,13 @@ impl RealizedFull {
         let investor_price_name = cfg.name("investor_price");
         let investor_price_version = cfg.version;
 
+        let realized_profit_rel_to_realized_cap =
+            cfg.import("realized_profit_rel_to_realized_cap", Version::new(2))?;
+        let realized_loss_rel_to_realized_cap =
+            cfg.import("realized_loss_rel_to_realized_cap", Version::new(2))?;
+        let net_realized_pnl_rel_to_realized_cap =
+            cfg.import("net_realized_pnl_rel_to_realized_cap", Version::new(2))?;
+
         let realized_profit_ema_1w = cfg.import("realized_profit_ema_1w", v0)?;
         let realized_loss_ema_1w = cfg.import("realized_loss_ema_1w", v0)?;
         let net_realized_pnl_ema_1w = cfg.import("net_realized_pnl_ema_1w", v0)?;
@@ -143,6 +154,9 @@ impl RealizedFull {
 
         Ok(Self {
             core,
+            realized_profit_rel_to_realized_cap,
+            realized_loss_rel_to_realized_cap,
+            net_realized_pnl_rel_to_realized_cap,
             profit_value_created,
             profit_value_destroyed,
             loss_value_created,
@@ -288,6 +302,29 @@ impl RealizedFull {
             exit,
         )?;
 
+        // Realized P/L rel to realized cap
+        self.realized_profit_rel_to_realized_cap
+            .compute_binary::<Cents, Cents, RatioCentsBp32>(
+                starting_indexes.height,
+                &self.core.minimal.realized_profit.height,
+                &self.core.minimal.realized_cap_cents.height,
+                exit,
+            )?;
+        self.realized_loss_rel_to_realized_cap
+            .compute_binary::<Cents, Cents, RatioCentsBp32>(
+                starting_indexes.height,
+                &self.core.minimal.realized_loss.height,
+                &self.core.minimal.realized_cap_cents.height,
+                exit,
+            )?;
+        self.net_realized_pnl_rel_to_realized_cap
+            .compute_binary::<CentsSigned, Cents, RatioCentsSignedCentsBps32>(
+                starting_indexes.height,
+                &self.core.net_realized_pnl.height,
+                &self.core.minimal.realized_cap_cents.height,
+                exit,
+            )?;
+
         // EMAs
         self.realized_profit_ema_1w.height.compute_rolling_ema(
             starting_indexes.height,

crates/brk_computer/src/distribution/metrics/relative/base.rs

@@ -1,61 +1,28 @@
 use brk_error::Result;
 use brk_traversable::Traversable;
-use brk_types::{BasisPoints16, BasisPointsSigned32, Dollars, Height, Sats, StoredF32, Version};
-use vecdb::{Exit, ReadableCloneableVec, ReadableVec, Rw, StorageMode};
+use brk_types::{BasisPoints16, Height, Sats, Version};
+use vecdb::{Exit, ReadableVec, Rw, StorageMode};
 
-use crate::internal::{
-    Bps32ToFloat, LazyFromHeight, NegRatioDollarsBps32, PercentFromHeight, RatioDollarsBp16,
-    RatioDollarsBps32, RatioSatsBp16,
-};
+use crate::internal::{PercentFromHeight, RatioSatsBp16};
 
 use crate::distribution::metrics::{ImportConfig, UnrealizedBase};
 
-/// Relative metrics for the Complete tier (~6 fields).
-///
-/// Excludes source-only fields (invested_capital_in_profit/loss_rel_to_realized_cap).
+/// Relative metrics for the Complete tier.
 #[derive(Traversable)]
 pub struct RelativeBase<M: StorageMode = Rw> {
     pub supply_in_profit_rel_to_own_supply: PercentFromHeight<BasisPoints16, M>,
     pub supply_in_loss_rel_to_own_supply: PercentFromHeight<BasisPoints16, M>,
-
-    pub unrealized_profit_rel_to_market_cap: PercentFromHeight<BasisPoints16, M>,
-    pub unrealized_loss_rel_to_market_cap: PercentFromHeight<BasisPoints16, M>,
-    pub net_unrealized_pnl_rel_to_market_cap: PercentFromHeight<BasisPointsSigned32, M>,
-    pub neg_unrealized_loss_rel_to_market_cap: PercentFromHeight<BasisPointsSigned32, M>,
-    pub nupl: LazyFromHeight<StoredF32, BasisPointsSigned32>,
 }
 
 impl RelativeBase {
     pub(crate) fn forced_import(cfg: &ImportConfig) -> Result<Self> {
         let v1 = Version::ONE;
-        let v2 = Version::new(2);
-
-        let net_unrealized_pnl_rel_to_market_cap: PercentFromHeight<BasisPointsSigned32> =
-            cfg.import("net_unrealized_pnl_rel_to_market_cap", Version::new(3))?;
-
-        let nupl = LazyFromHeight::from_computed::<Bps32ToFloat>(
-            &cfg.name("nupl"),
-            cfg.version + Version::new(3),
-            net_unrealized_pnl_rel_to_market_cap
-                .bps
-                .height
-                .read_only_boxed_clone(),
-            &net_unrealized_pnl_rel_to_market_cap.bps,
-        );
 
         Ok(Self {
             supply_in_profit_rel_to_own_supply: cfg
                 .import("supply_in_profit_rel_to_own_supply", v1)?,
             supply_in_loss_rel_to_own_supply: cfg
                 .import("supply_in_loss_rel_to_own_supply", v1)?,
-            unrealized_profit_rel_to_market_cap: cfg
-                .import("unrealized_profit_rel_to_market_cap", v2)?,
-            unrealized_loss_rel_to_market_cap: cfg
-                .import("unrealized_loss_rel_to_market_cap", v2)?,
-            net_unrealized_pnl_rel_to_market_cap,
-            neg_unrealized_loss_rel_to_market_cap: cfg
-                .import("neg_unrealized_loss_rel_to_market_cap", Version::new(3))?,
-            nupl,
         })
     }
 
@@ -64,7 +31,6 @@ impl RelativeBase {
         max_from: Height,
         unrealized: &UnrealizedBase,
         supply_total_sats: &impl ReadableVec<Height, Sats>,
-        market_cap: &impl ReadableVec<Height, Dollars>,
         exit: &Exit,
     ) -> Result<()> {
         self.supply_in_profit_rel_to_own_supply
@@ -81,34 +47,6 @@ impl RelativeBase {
                 supply_total_sats,
                 exit,
             )?;
-        self.unrealized_profit_rel_to_market_cap
-            .compute_binary::<Dollars, Dollars, RatioDollarsBp16>(
-                max_from,
-                &unrealized.unrealized_profit.usd.height,
-                market_cap,
-                exit,
-            )?;
-        self.unrealized_loss_rel_to_market_cap
-            .compute_binary::<Dollars, Dollars, RatioDollarsBp16>(
-                max_from,
-                &unrealized.unrealized_loss.usd.height,
-                market_cap,
-                exit,
-            )?;
-        self.net_unrealized_pnl_rel_to_market_cap
-            .compute_binary::<Dollars, Dollars, RatioDollarsBps32>(
-                max_from,
-                &unrealized.net_unrealized_pnl.usd.height,
-                market_cap,
-                exit,
-            )?;
-        self.neg_unrealized_loss_rel_to_market_cap
-            .compute_binary::<Dollars, Dollars, NegRatioDollarsBps32>(
-                max_from,
-                &unrealized.unrealized_loss.usd.height,
-                market_cap,
-                exit,
-            )?;
         Ok(())
     }
 }

crates/brk_computer/src/distribution/metrics/relative/full.rs

@@ -1,19 +1,21 @@
 use brk_error::Result;
 use brk_traversable::Traversable;
-use brk_types::{BasisPoints16, Dollars, Height, Sats, Version};
+use brk_types::{
+    BasisPoints16, BasisPointsSigned32, Dollars, Height, Sats, StoredF32, Version,
+};
 use derive_more::{Deref, DerefMut};
-use vecdb::{Exit, ReadableVec, Rw, StorageMode};
+use vecdb::{Exit, ReadableCloneableVec, ReadableVec, Rw, StorageMode};
 
-use crate::internal::{PercentFromHeight, RatioDollarsBp16};
+use crate::internal::{
+    Bps32ToFloat, LazyFromHeight, NegRatioDollarsBps32, PercentFromHeight, RatioDollarsBp16,
+    RatioDollarsBps32,
+};
 
 use crate::distribution::metrics::{ImportConfig, RealizedBase, UnrealizedFull};
 
 use super::RelativeBase;
 
 /// Full relative metrics (Source/Extended tier).
-///
-/// Contains all Complete-tier fields (via Deref to RelativeBase) plus:
-/// - Source-only: invested_capital_in_profit/loss_rel_to_realized_cap
 #[derive(Deref, DerefMut, Traversable)]
 pub struct RelativeFull<M: StorageMode = Rw> {
     #[deref]
@@ -21,7 +23,12 @@ pub struct RelativeFull<M: StorageMode = Rw> {
     #[traversable(flatten)]
     pub base: RelativeBase<M>,
 
-    // --- Source-only fields ---
+    pub unrealized_profit_rel_to_market_cap: PercentFromHeight<BasisPoints16, M>,
+    pub unrealized_loss_rel_to_market_cap: PercentFromHeight<BasisPoints16, M>,
+    pub net_unrealized_pnl_rel_to_market_cap: PercentFromHeight<BasisPointsSigned32, M>,
+    pub neg_unrealized_loss_rel_to_market_cap: PercentFromHeight<BasisPointsSigned32, M>,
+    pub nupl: LazyFromHeight<StoredF32, BasisPointsSigned32>,
+
     pub invested_capital_in_profit_rel_to_realized_cap: PercentFromHeight<BasisPoints16, M>,
     pub invested_capital_in_loss_rel_to_realized_cap: PercentFromHeight<BasisPoints16, M>,
 }
@@ -30,8 +37,32 @@ impl RelativeFull {
     pub(crate) fn forced_import(cfg: &ImportConfig) -> Result<Self> {
         let base = RelativeBase::forced_import(cfg)?;
 
+        let v2 = Version::new(2);
+        let v3 = Version::new(3);
+
+        let net_unrealized_pnl_rel_to_market_cap: PercentFromHeight<BasisPointsSigned32> =
+            cfg.import("net_unrealized_pnl_rel_to_market_cap", v3)?;
+
+        let nupl = LazyFromHeight::from_computed::<Bps32ToFloat>(
+            &cfg.name("nupl"),
+            cfg.version + v3,
+            net_unrealized_pnl_rel_to_market_cap
+                .bps
+                .height
+                .read_only_boxed_clone(),
+            &net_unrealized_pnl_rel_to_market_cap.bps,
+        );
+
         Ok(Self {
             base,
+            unrealized_profit_rel_to_market_cap: cfg
+                .import("unrealized_profit_rel_to_market_cap", v2)?,
+            unrealized_loss_rel_to_market_cap: cfg
+                .import("unrealized_loss_rel_to_market_cap", v2)?,
+            net_unrealized_pnl_rel_to_market_cap,
+            neg_unrealized_loss_rel_to_market_cap: cfg
+                .import("neg_unrealized_loss_rel_to_market_cap", v3)?,
+            nupl,
             invested_capital_in_profit_rel_to_realized_cap: cfg.import(
                 "invested_capital_in_profit_rel_to_realized_cap",
                 Version::ZERO,
@@ -52,16 +83,42 @@ impl RelativeFull {
         market_cap: &impl ReadableVec<Height, Dollars>,
         exit: &Exit,
     ) -> Result<()> {
-        // Compute Complete-tier fields
         self.base.compute(
             max_from,
             &unrealized.base,
             supply_total_sats,
-            market_cap,
             exit,
         )?;
 
-        // Source-only
+        self.unrealized_profit_rel_to_market_cap
+            .compute_binary::<Dollars, Dollars, RatioDollarsBp16>(
+                max_from,
+                &unrealized.unrealized_profit.usd.height,
+                market_cap,
+                exit,
+            )?;
+        self.unrealized_loss_rel_to_market_cap
+            .compute_binary::<Dollars, Dollars, RatioDollarsBp16>(
+                max_from,
+                &unrealized.unrealized_loss.usd.height,
+                market_cap,
+                exit,
+            )?;
+        self.net_unrealized_pnl_rel_to_market_cap
+            .compute_binary::<Dollars, Dollars, RatioDollarsBps32>(
+                max_from,
+                &unrealized.net_unrealized_pnl.usd.height,
+                market_cap,
+                exit,
+            )?;
+        self.neg_unrealized_loss_rel_to_market_cap
+            .compute_binary::<Dollars, Dollars, NegRatioDollarsBps32>(
+                max_from,
+                &unrealized.unrealized_loss.usd.height,
+                market_cap,
+                exit,
+            )?;
+
         self.invested_capital_in_profit_rel_to_realized_cap
             .compute_binary::<Dollars, Dollars, RatioDollarsBp16>(
                 max_from,

crates/brk_computer/src/distribution/metrics/relative/with_rel_to_all_base.rs

@@ -1,6 +1,6 @@
 use brk_error::Result;
 use brk_traversable::Traversable;
-use brk_types::{Dollars, Height, Sats};
+use brk_types::{Height, Sats};
 use derive_more::{Deref, DerefMut};
 use vecdb::{Exit, ReadableVec, Rw, StorageMode};
 
@@ -33,7 +33,6 @@ impl RelativeBaseWithRelToAll {
         max_from: Height,
         unrealized: &UnrealizedBase,
         supply_total_sats: &impl ReadableVec<Height, Sats>,
-        market_cap: &impl ReadableVec<Height, Dollars>,
         all_supply_sats: &impl ReadableVec<Height, Sats>,
         exit: &Exit,
     ) -> Result<()> {
@@ -41,7 +40,6 @@ impl RelativeBaseWithRelToAll {
             max_from,
             unrealized,
             supply_total_sats,
-            market_cap,
             exit,
         )?;
         self.rel_to_all.compute(

crates/brk_computer/src/pools/major.rs

@@ -1,26 +1,31 @@
 use brk_error::Result;
 use brk_traversable::Traversable;
 use brk_types::{BasisPoints16, Height, Indexes, PoolSlug, StoredU32};
-use vecdb::{
-    BinaryTransform, Database, Exit, ReadableVec, Rw, StorageMode, Version,
-};
+use derive_more::{Deref, DerefMut};
+use vecdb::{BinaryTransform, Database, Exit, ReadableVec, Rw, StorageMode, Version};
 
 use crate::{
     blocks, indexes,
     internal::{
-        ComputedFromHeightCumulativeSum, MaskSats, PercentFromHeight,
-        PercentRollingWindows, RatioU32Bp16, ValueFromHeightCumulativeSum,
+        MaskSats, PercentRollingWindows, RatioU32Bp16, RollingWindows,
+        ValueFromHeightCumulativeSum,
     },
     mining, prices,
 };
 
-#[derive(Traversable)]
-pub struct Vecs<M: StorageMode = Rw> {
-    slug: PoolSlug,
+use super::minor;
 
-    pub blocks_mined: ComputedFromHeightCumulativeSum<StoredU32, M>,
+#[derive(Deref, DerefMut, Traversable)]
+#[traversable(merge)]
+pub struct Vecs<M: StorageMode = Rw> {
+    #[deref]
+    #[deref_mut]
+    #[traversable(flatten)]
+    pub base: minor::Vecs<M>,
+
+    #[traversable(wrap = "blocks_mined", rename = "sum")]
+    pub blocks_mined_sum: RollingWindows<StoredU32, M>,
     pub rewards: ValueFromHeightCumulativeSum<M>,
-    pub dominance: PercentFromHeight<BasisPoints16, M>,
     pub dominance_rolling: PercentRollingWindows<BasisPoints16, M>,
 }
 
@@ -28,33 +33,27 @@ impl Vecs {
     pub(crate) fn forced_import(
         db: &Database,
         slug: PoolSlug,
-        parent_version: Version,
+        version: Version,
         indexes: &indexes::Vecs,
     ) -> Result<Self> {
         let suffix = |s: &str| format!("{}_{s}", slug);
-        let version = parent_version;
 
-        let blocks_mined = ComputedFromHeightCumulativeSum::forced_import(
-            db,
-            &suffix("blocks_mined"),
-            version,
-            indexes,
-        )?;
+        let base = minor::Vecs::forced_import(db, slug, version, indexes)?;
+
+        let blocks_mined_sum =
+            RollingWindows::forced_import(db, &suffix("blocks_mined"), version, indexes)?;
 
         let rewards =
             ValueFromHeightCumulativeSum::forced_import(db, &suffix("rewards"), version, indexes)?;
 
-        let dominance =
-            PercentFromHeight::forced_import(db, &suffix("dominance"), version, indexes)?;
         let dominance_rolling =
             PercentRollingWindows::forced_import(db, &suffix("dominance"), version, indexes)?;
 
         Ok(Self {
-            dominance,
-            dominance_rolling,
-            slug,
-            blocks_mined,
+            base,
+            blocks_mined_sum,
             rewards,
+            dominance_rolling,
         })
     }
 
@@ -68,42 +67,28 @@ impl Vecs {
         mining: &mining::Vecs,
         exit: &Exit,
     ) -> Result<()> {
+        self.base
+            .compute(starting_indexes, height_to_pool, blocks, exit)?;
+
         let window_starts = blocks.count.window_starts();
 
-        self.blocks_mined
-            .compute(starting_indexes.height, &window_starts, exit, |vec| {
-                vec.compute_transform(
-                    starting_indexes.height,
-                    height_to_pool,
-                    |(h, id, ..)| {
-                        (
-                            h,
-                            if id == self.slug {
-                                StoredU32::ONE
-                            } else {
-                                StoredU32::ZERO
-                            },
-                        )
-                    },
-                    exit,
-                )?;
-                Ok(())
-            })?;
+        self.blocks_mined_sum.compute_rolling_sum(
+            starting_indexes.height,
+            &window_starts,
+            &self.base.blocks_mined.height,
+            exit,
+        )?;
 
-        self.dominance
-            .compute_binary::<StoredU32, StoredU32, RatioU32Bp16>(
-                starting_indexes.height,
-                &self.blocks_mined.cumulative.height,
-                &blocks.count.block_count.cumulative.height,
-                exit,
-            )?;
-
-        for ((dom, mined), total) in self
+        for (dom, (mined, total)) in self
             .dominance_rolling
             .as_mut_array()
             .into_iter()
-            .zip(self.blocks_mined.sum.as_array())
-            .zip(blocks.count.block_count_sum.as_array())
+            .zip(
+                self.blocks_mined_sum
+                    .as_array()
+                    .into_iter()
+                    .zip(blocks.count.block_count_sum.as_array()),
+            )
         {
             dom.compute_binary::<StoredU32, StoredU32, RatioU32Bp16>(
                 starting_indexes.height,
@@ -121,7 +106,7 @@ impl Vecs {
             |vec| {
                 Ok(vec.compute_transform2(
                     starting_indexes.height,
-                    &self.blocks_mined.height,
+                    &self.base.blocks_mined.height,
                     &mining.rewards.coinbase.base.sats.height,
                     |(h, mask, val, ..)| (h, MaskSats::apply(mask, val)),
                     exit,

crates/brk_computer/src/pools/minor.rs

@@ -0,0 +1,85 @@
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{BasisPoints16, Height, Indexes, PoolSlug, StoredU32};
+use vecdb::{
+    Database, Exit, ReadableVec, Rw, StorageMode, Version,
+};
+
+use crate::{
+    blocks, indexes,
+    internal::{ComputedFromHeightCumulative, PercentFromHeight, RatioU32Bp16},
+};
+
+#[derive(Traversable)]
+pub struct Vecs<M: StorageMode = Rw> {
+    #[traversable(skip)]
+    slug: PoolSlug,
+
+    pub blocks_mined: ComputedFromHeightCumulative<StoredU32, M>,
+    pub dominance: PercentFromHeight<BasisPoints16, M>,
+}
+
+impl Vecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        slug: PoolSlug,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let suffix = |s: &str| format!("{}_{s}", slug);
+
+        let blocks_mined = ComputedFromHeightCumulative::forced_import(
+            db,
+            &suffix("blocks_mined"),
+            version,
+            indexes,
+        )?;
+
+        let dominance =
+            PercentFromHeight::forced_import(db, &suffix("dominance"), version, indexes)?;
+
+        Ok(Self {
+            slug,
+            blocks_mined,
+            dominance,
+        })
+    }
+
+    pub(crate) fn compute(
+        &mut self,
+        starting_indexes: &Indexes,
+        height_to_pool: &impl ReadableVec<Height, PoolSlug>,
+        blocks: &blocks::Vecs,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.blocks_mined
+            .compute(starting_indexes.height, exit, |vec| {
+                vec.compute_transform(
+                    starting_indexes.height,
+                    height_to_pool,
+                    |(h, id, ..)| {
+                        (
+                            h,
+                            if id == self.slug {
+                                StoredU32::ONE
+                            } else {
+                                StoredU32::ZERO
+                            },
+                        )
+                    },
+                    exit,
+                )?;
+                Ok(())
+            })?;
+
+        self.dominance
+            .compute_binary::<StoredU32, StoredU32, RatioU32Bp16>(
+                starting_indexes.height,
+                &self.blocks_mined.cumulative.height,
+                &blocks.count.block_count.cumulative.height,
+                exit,
+            )?;
+
+        Ok(())
+    }
+}

crates/brk_computer/src/pools/mod.rs

@@ -13,7 +13,8 @@ use vecdb::{
     VecIndex, Version, WritableVec,
 };
 
-mod vecs;
+pub mod major;
+pub mod minor;
 
 use crate::{
     blocks, indexes,
@@ -29,7 +30,8 @@ pub struct Vecs<M: StorageMode = Rw> {
     pools: &'static Pools,
 
     pub height_to_pool: M::Stored<BytesVec<Height, PoolSlug>>,
-    pub vecs: BTreeMap<PoolSlug, vecs::Vecs<M>>,
+    pub major: BTreeMap<PoolSlug, major::Vecs<M>>,
+    pub minor: BTreeMap<PoolSlug, minor::Vecs<M>>,
 }
 
 impl Vecs {
@@ -43,15 +45,27 @@ impl Vecs {
 
         let version = parent_version + Version::new(3) + Version::new(pools.len() as u32);
 
+        let mut major_map = BTreeMap::new();
+        let mut minor_map = BTreeMap::new();
+
+        for pool in pools.iter() {
+            if pool.slug.is_major() {
+                major_map.insert(
+                    pool.slug,
+                    major::Vecs::forced_import(&db, pool.slug, version, indexes)?,
+                );
+            } else {
+                minor_map.insert(
+                    pool.slug,
+                    minor::Vecs::forced_import(&db, pool.slug, version, indexes)?,
+                );
+            }
+        }
+
         let this = Self {
             height_to_pool: BytesVec::forced_import(&db, "pool", version)?,
-            vecs: pools
-                .iter()
-                .map(|pool| {
-                    vecs::Vecs::forced_import(&db, pool.slug, version, indexes)
-                        .map(|vecs| (pool.slug, vecs))
-                })
-                .collect::<Result<BTreeMap<_, _>>>()?,
+            major: major_map,
+            minor: minor_map,
             pools,
             db,
         };
@@ -73,7 +87,7 @@ impl Vecs {
     ) -> Result<()> {
         self.compute_height_to_pool(indexer, indexes, starting_indexes, exit)?;
 
-        self.vecs.par_iter_mut().try_for_each(|(_, vecs)| {
+        self.major.par_iter_mut().try_for_each(|(_, vecs)| {
             vecs.compute(
                 starting_indexes,
                 &self.height_to_pool,
@@ -84,6 +98,10 @@ impl Vecs {
             )
         })?;
 
+        self.minor.par_iter_mut().try_for_each(|(_, vecs)| {
+            vecs.compute(starting_indexes, &self.height_to_pool, blocks, exit)
+        })?;
+
         let _lock = exit.lock();
         self.db.compact()?;
         Ok(())

crates/brk_query/src/impl/mining/pools.rs

@@ -29,9 +29,19 @@ impl Query {
         let mut pool_data: Vec<(&'static brk_types::Pool, u32)> = Vec::new();
 
         // For each pool, get cumulative count at end and start, subtract to get range count
-        for (pool_id, pool_vecs) in &computer.pools.vecs {
-            let cumulative = &pool_vecs.blocks_mined.cumulative.height;
-
+        for (pool_id, cumulative) in computer
+            .pools
+            .major
+            .iter()
+            .map(|(id, v)| (id, &v.blocks_mined.cumulative.height))
+            .chain(
+                computer
+                    .pools
+                    .minor
+                    .iter()
+                    .map(|(id, v)| (id, &v.blocks_mined.cumulative.height)),
+            )
+        {
             let count_at_end: u32 = *cumulative.collect_one(current_height).unwrap_or_default();
 
             let count_at_start: u32 = if start == 0 {
@@ -44,7 +54,6 @@ impl Query {
 
             let block_count = count_at_end.saturating_sub(count_at_start);
 
-            // Only include pools that mined at least one block in the period
             if block_count > 0 {
                 pool_data.push((pools.get(*pool_id), block_count));
             }
@@ -91,15 +100,21 @@ impl Query {
         let pools_list = pools();
         let pool = pools_list.get(slug);
 
-        // Get pool vecs for this specific pool
-        let pool_vecs = computer
+        // Get cumulative blocks for this pool (works for both major and minor)
+        let cumulative = computer
             .pools
-            .vecs
+            .major
             .get(&slug)
+            .map(|v| &v.blocks_mined.cumulative.height)
+            .or_else(|| {
+                computer
+                    .pools
+                    .minor
+                    .get(&slug)
+                    .map(|v| &v.blocks_mined.cumulative.height)
+            })
             .ok_or_else(|| Error::NotFound("Pool data not found".into()))?;
 
-        let cumulative = &pool_vecs.blocks_mined.cumulative.height;
-
         // Get total blocks (all time)
         let total_all: u32 = *cumulative.collect_one(current_height).unwrap_or_default();
 

crates/brk_types/src/poolslug.rs

@@ -376,6 +376,90 @@ pub enum PoolSlug {
     Dummy255,
 }
 
+impl PoolSlug {
+    /// Pools with ≥0.01% all-time dominance get full metrics (rolling windows, rewards, etc.).
+    pub fn is_major(&self) -> bool {
+        matches!(
+            self,
+            Self::Unknown
+                | Self::AntPool
+                | Self::AsicMiner
+                | Self::BatPool
+                | Self::BinancePool
+                | Self::BitClub
+                | Self::BitcoinAffiliateNetwork
+                | Self::BitcoinCom
+                | Self::BitcoinIndia
+                | Self::BitcoinRussia
+                | Self::BitFury
+                | Self::BitMinter
+                | Self::Bitparking
+                | Self::Bixin
+                | Self::BraiinsPool
+                | Self::Btcc
+                | Self::BtcCom
+                | Self::BtcGuild
+                | Self::BtcTop
+                | Self::BtPool
+                | Self::BwPool
+                | Self::BytePool
+                | Self::CanoePool
+                | Self::CoinLab
+                | Self::ConnectBtc
+                | Self::DigitalBtc
+                | Self::DPool
+                | Self::EclipseMc
+                | Self::Eligius
+                | Self::EmcdPool
+                | Self::ExxBw
+                | Self::F2Pool
+                | Self::FiftyEightCoin
+                | Self::FoundryUsa
+                | Self::GbMiners
+                | Self::GhashIo
+                | Self::Hhtt
+                | Self::HuobiPool
+                | Self::KanoPool
+                | Self::KncMiner
+                | Self::KuCoinPool
+                | Self::LubianCom
+                | Self::Luxor
+                | Self::MaraPool
+                | Self::MaxBtc
+                | Self::MegaBigPower
+                | Self::NiceHash
+                | Self::NmcBit
+                | Self::NovaBlock
+                | Self::Ocean
+                | Self::OkExPool
+                | Self::Okkong
+                | Self::OkpoolTop
+                | Self::OneThash
+                | Self::OzCoin
+                | Self::PegaPool
+                | Self::Polmine
+                | Self::Pool50btc
+                | Self::Poolin
+                | Self::SbiCrypto
+                | Self::SecPool
+                | Self::SecretSuperstar
+                | Self::SigmapoolCom
+                | Self::SoloCk
+                | Self::SpiderPool
+                | Self::Tangpool
+                | Self::TatmasPool
+                | Self::TerraPool
+                | Self::TigerpoolNet
+                | Self::TripleMining
+                | Self::UltimusPool
+                | Self::ViaBtc
+                | Self::WayiCn
+                | Self::WhitePool
+                | Self::YourbtcNet
+        )
+    }
+}
+
 impl Formattable for PoolSlug {
     #[inline(always)]
     fn fmt_csv(&self, f: &mut String) -> std::fmt::Result {

packages/brk_client/brk_client/__init__.py

@@ -2158,34 +2158,6 @@ class _0sdM0M1M1sdM2M2sdM3sdP0P1P1sdP2P2sdP3sdSdSmaZscorePattern:
         self.sma: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'sma_4y'))
         self.zscore: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'zscore_4y'))
 
-class GrossMvrvNegNetRealizedSentSoprValuePattern:
-    """Pattern struct for repeated tree structure."""
-    
-    def __init__(self, client: BrkClientBase, acc: str):
-        """Create pattern node with accumulated metric name."""
-        self.gross_pnl: CentsUsdPattern = CentsUsdPattern(client, _m(acc, 'realized_gross_pnl'))
-        self.mvrv: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'mvrv'))
-        self.neg_realized_loss: MetricPattern1[Dollars] = MetricPattern1(client, _m(acc, 'neg_realized_loss'))
-        self.net_realized_pnl: CumulativeHeightPattern[CentsSigned] = CumulativeHeightPattern(client, _m(acc, 'net_realized_pnl'))
-        self.net_realized_pnl_rel_to_realized_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'net_realized_pnl_rel_to_realized_cap'))
-        self.realized_cap: MetricPattern1[Dollars] = MetricPattern1(client, _m(acc, 'realized_cap'))
-        self.realized_cap_cents: MetricPattern1[Cents] = MetricPattern1(client, _m(acc, 'realized_cap_cents'))
-        self.realized_cap_change_1m: MetricPattern1[CentsSigned] = MetricPattern1(client, _m(acc, 'realized_cap_change_1m'))
-        self.realized_loss: CumulativeHeightPattern[Cents] = CumulativeHeightPattern(client, _m(acc, 'realized_loss'))
-        self.realized_loss_rel_to_realized_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'realized_loss_rel_to_realized_cap'))
-        self.realized_price: CentsSatsUsdPattern = CentsSatsUsdPattern(client, _m(acc, 'realized_price'))
-        self.realized_price_ratio: BpsRatioPattern = BpsRatioPattern(client, _m(acc, 'realized_price_ratio'))
-        self.realized_price_ratio_percentiles: RatioPattern = RatioPattern(client, _m(acc, 'realized_price_ratio'))
-        self.realized_profit: CumulativeHeightPattern[Cents] = CumulativeHeightPattern(client, _m(acc, 'realized_profit'))
-        self.realized_profit_rel_to_realized_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'realized_profit_rel_to_realized_cap'))
-        self.sent_in_loss: BaseCumulativePattern = BaseCumulativePattern(client, _m(acc, 'sent_in_loss'))
-        self.sent_in_profit: BaseCumulativePattern = BaseCumulativePattern(client, _m(acc, 'sent_in_profit'))
-        self.sopr: _1m1w1y24hPattern[StoredF64] = _1m1w1y24hPattern(client, _m(acc, 'sopr'))
-        self.value_created: MetricPattern1[Cents] = MetricPattern1(client, _m(acc, 'value_created'))
-        self.value_created_sum: _1m1w1y24hPattern[Cents] = _1m1w1y24hPattern(client, _m(acc, 'value_created'))
-        self.value_destroyed: MetricPattern1[Cents] = MetricPattern1(client, _m(acc, 'value_destroyed'))
-        self.value_destroyed_sum: _1m1w1y24hPattern[Cents] = _1m1w1y24hPattern(client, _m(acc, 'value_destroyed'))
-
 class InvestedNegNetNuplSupplyUnrealizedPattern3:
     """Pattern struct for repeated tree structure."""
     
@@ -2212,6 +2184,31 @@ class InvestedNegNetNuplSupplyUnrealizedPattern3:
         self.unrealized_profit_rel_to_own_gross_pnl: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'unrealized_profit_rel_to_own_gross_pnl'))
         self.unrealized_profit_rel_to_own_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'unrealized_profit_rel_to_own_market_cap'))
 
+class GrossMvrvNegNetRealizedSentSoprValuePattern:
+    """Pattern struct for repeated tree structure."""
+    
+    def __init__(self, client: BrkClientBase, acc: str):
+        """Create pattern node with accumulated metric name."""
+        self.gross_pnl: CentsUsdPattern = CentsUsdPattern(client, _m(acc, 'realized_gross_pnl'))
+        self.mvrv: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'mvrv'))
+        self.neg_realized_loss: MetricPattern1[Dollars] = MetricPattern1(client, _m(acc, 'neg_realized_loss'))
+        self.net_realized_pnl: CumulativeHeightPattern[CentsSigned] = CumulativeHeightPattern(client, _m(acc, 'net_realized_pnl'))
+        self.realized_cap: MetricPattern1[Dollars] = MetricPattern1(client, _m(acc, 'realized_cap'))
+        self.realized_cap_cents: MetricPattern1[Cents] = MetricPattern1(client, _m(acc, 'realized_cap_cents'))
+        self.realized_cap_change_1m: MetricPattern1[CentsSigned] = MetricPattern1(client, _m(acc, 'realized_cap_change_1m'))
+        self.realized_loss: CumulativeHeightPattern[Cents] = CumulativeHeightPattern(client, _m(acc, 'realized_loss'))
+        self.realized_price: CentsSatsUsdPattern = CentsSatsUsdPattern(client, _m(acc, 'realized_price'))
+        self.realized_price_ratio: BpsRatioPattern = BpsRatioPattern(client, _m(acc, 'realized_price_ratio'))
+        self.realized_price_ratio_percentiles: RatioPattern = RatioPattern(client, _m(acc, 'realized_price_ratio'))
+        self.realized_profit: CumulativeHeightPattern[Cents] = CumulativeHeightPattern(client, _m(acc, 'realized_profit'))
+        self.sent_in_loss: BaseCumulativePattern = BaseCumulativePattern(client, _m(acc, 'sent_in_loss'))
+        self.sent_in_profit: BaseCumulativePattern = BaseCumulativePattern(client, _m(acc, 'sent_in_profit'))
+        self.sopr: _1m1w1y24hPattern[StoredF64] = _1m1w1y24hPattern(client, _m(acc, 'sopr'))
+        self.value_created: MetricPattern1[Cents] = MetricPattern1(client, _m(acc, 'value_created'))
+        self.value_created_sum: _1m1w1y24hPattern[Cents] = _1m1w1y24hPattern(client, _m(acc, 'value_created'))
+        self.value_destroyed: MetricPattern1[Cents] = MetricPattern1(client, _m(acc, 'value_destroyed'))
+        self.value_destroyed_sum: _1m1w1y24hPattern[Cents] = _1m1w1y24hPattern(client, _m(acc, 'value_destroyed'))
+
 class Pct05Pct10Pct15Pct20Pct25Pct30Pct35Pct40Pct45Pct50Pct55Pct60Pct65Pct70Pct75Pct80Pct85Pct90Pct95Pattern:
     """Pattern struct for repeated tree structure."""
     
@@ -2355,6 +2352,23 @@ class InvestedNegNetNuplSupplyUnrealizedPattern:
         self.unrealized_loss_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'unrealized_loss_rel_to_market_cap'))
         self.unrealized_profit_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'unrealized_profit_rel_to_market_cap'))
 
+class _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern:
+    """Pattern struct for repeated tree structure."""
+    
+    def __init__(self, client: BrkClientBase, acc: str):
+        """Create pattern node with accumulated metric name."""
+        self._1m: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'dominance_1m'))
+        self._1w: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'dominance_1w'))
+        self._1y: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'dominance_1y'))
+        self._24h: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'dominance_24h'))
+        self.base: BtcCentsSatsUsdPattern = BtcCentsSatsUsdPattern(client, _m(acc, 'rewards'))
+        self.bps: MetricPattern1[BasisPoints16] = MetricPattern1(client, _m(acc, 'dominance_bps'))
+        self.cumulative: BaseBtcCentsSatsUsdPattern = BaseBtcCentsSatsUsdPattern(client, acc)
+        self.height: MetricPattern18[StoredU32] = MetricPattern18(client, _m(acc, 'blocks_mined'))
+        self.percent: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'dominance'))
+        self.ratio: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'dominance_ratio'))
+        self.sum: _1m1w1y24hPattern6 = _1m1w1y24hPattern6(client, acc)
+
 class AverageCumulativeMaxMedianMinPct10Pct25Pct75Pct90RollingSumPattern:
     """Pattern struct for repeated tree structure."""
     
@@ -2405,22 +2419,6 @@ class AverageGainsLossesRsiStochPattern:
         self.stoch_rsi_d: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'stoch_d_24h'))
         self.stoch_rsi_k: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'stoch_k_24h'))
 
-class NegNetNuplSupplyUnrealizedPattern:
-    """Pattern struct for repeated tree structure."""
-    
-    def __init__(self, client: BrkClientBase, acc: str):
-        """Create pattern node with accumulated metric name."""
-        self.neg_unrealized_loss_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'neg_unrealized_loss_rel_to_market_cap'))
-        self.net_unrealized_pnl_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'net_unrealized_pnl_rel_to_market_cap'))
-        self.nupl: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'nupl'))
-        self.supply_in_loss_rel_to_circulating_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'supply_in_loss_rel_to_circulating_supply'))
-        self.supply_in_loss_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'supply_in_loss_rel_to_own_supply'))
-        self.supply_in_profit_rel_to_circulating_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'supply_in_profit_rel_to_circulating_supply'))
-        self.supply_in_profit_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'supply_in_profit_rel_to_own_supply'))
-        self.supply_rel_to_circulating_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'supply_rel_to_circulating_supply'))
-        self.unrealized_loss_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'unrealized_loss_rel_to_market_cap'))
-        self.unrealized_profit_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'unrealized_profit_rel_to_market_cap'))
-
 class AllP2aP2pk33P2pk65P2pkhP2shP2trP2wpkhP2wshPattern:
     """Pattern struct for repeated tree structure."""
     
@@ -2595,7 +2593,7 @@ class ActivityOutputsRealizedRelativeSupplyUnrealizedPattern2:
         self.activity: SentPattern = SentPattern(client, _m(acc, 'sent'))
         self.outputs: UtxoPattern = UtxoPattern(client, _m(acc, 'utxo_count'))
         self.realized: GrossMvrvNegNetRealizedSentSoprValuePattern = GrossMvrvNegNetRealizedSentSoprValuePattern(client, acc)
-        self.relative: NegNetNuplSupplyUnrealizedPattern = NegNetNuplSupplyUnrealizedPattern(client, acc)
+        self.relative: SupplyPattern3 = SupplyPattern3(client, _m(acc, 'supply'))
         self.supply: ChangeHalvedTotalPattern = ChangeHalvedTotalPattern(client, _m(acc, 'supply'))
         self.unrealized: GrossNegNetSupplyUnrealizedPattern = GrossNegNetSupplyUnrealizedPattern(client, acc)
 
@@ -2623,6 +2621,17 @@ class BalanceBothReactivatedReceivingSendingPattern:
         self.receiving: AverageHeightMaxMedianMinPct10Pct25Pct75Pct90Pattern[StoredU32] = AverageHeightMaxMedianMinPct10Pct25Pct75Pct90Pattern(client, _m(acc, 'receiving'))
         self.sending: AverageHeightMaxMedianMinPct10Pct25Pct75Pct90Pattern[StoredU32] = AverageHeightMaxMedianMinPct10Pct25Pct75Pct90Pattern(client, _m(acc, 'sending'))
 
+class BaseBtcCentsSatsUsdPattern:
+    """Pattern struct for repeated tree structure."""
+    
+    def __init__(self, client: BrkClientBase, acc: str):
+        """Create pattern node with accumulated metric name."""
+        self.base: MetricPattern1[StoredU32] = MetricPattern1(client, _m(acc, 'blocks_mined_cumulative'))
+        self.btc: MetricPattern1[Bitcoin] = MetricPattern1(client, _m(acc, 'rewards_cumulative_btc'))
+        self.cents: MetricPattern1[Cents] = MetricPattern1(client, _m(acc, 'rewards_cumulative_cents'))
+        self.sats: MetricPattern1[Sats] = MetricPattern1(client, _m(acc, 'rewards_cumulative'))
+        self.usd: MetricPattern1[Dollars] = MetricPattern1(client, _m(acc, 'rewards_cumulative_usd'))
+
 class EmaHistogramLineSignalPattern:
     """Pattern struct for repeated tree structure."""
     
@@ -2634,6 +2643,27 @@ class EmaHistogramLineSignalPattern:
         self.line: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'line_24h'))
         self.signal: MetricPattern1[StoredF32] = MetricPattern1(client, _m(acc, 'signal_24h'))
 
+class SupplyPattern3:
+    """Pattern struct for repeated tree structure."""
+    
+    def __init__(self, client: BrkClientBase, acc: str):
+        """Create pattern node with accumulated metric name."""
+        self.supply_in_loss_rel_to_circulating_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'in_loss_rel_to_circulating_supply'))
+        self.supply_in_loss_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'in_loss_rel_to_own_supply'))
+        self.supply_in_profit_rel_to_circulating_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'in_profit_rel_to_circulating_supply'))
+        self.supply_in_profit_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'in_profit_rel_to_own_supply'))
+        self.supply_rel_to_circulating_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'rel_to_circulating_supply'))
+
+class _1m1w1y24hPattern6:
+    """Pattern struct for repeated tree structure."""
+    
+    def __init__(self, client: BrkClientBase, acc: str):
+        """Create pattern node with accumulated metric name."""
+        self._1m: BaseBtcCentsSatsUsdPattern = BaseBtcCentsSatsUsdPattern(client, acc)
+        self._1w: BaseBtcCentsSatsUsdPattern = BaseBtcCentsSatsUsdPattern(client, acc)
+        self._1y: BaseBtcCentsSatsUsdPattern = BaseBtcCentsSatsUsdPattern(client, acc)
+        self._24h: BaseBtcCentsSatsUsdPattern = BaseBtcCentsSatsUsdPattern(client, acc)
+
 class _1m1w1y24hPattern2:
     """Pattern struct for repeated tree structure."""
     
@@ -2654,16 +2684,6 @@ class _1m1w1y24hPattern5:
         self._1y: BtcCentsSatsUsdPattern = BtcCentsSatsUsdPattern(client, _m(acc, '1y'))
         self._24h: BtcCentsSatsUsdPattern = BtcCentsSatsUsdPattern(client, _m(acc, '24h'))
 
-class BlocksDominanceRewardsPattern:
-    """Pattern struct for repeated tree structure."""
-    
-    def __init__(self, client: BrkClientBase, acc: str):
-        """Create pattern node with accumulated metric name."""
-        self.blocks_mined: CumulativeHeightSumPattern[StoredU32] = CumulativeHeightSumPattern(client, _m(acc, 'blocks_mined'))
-        self.dominance: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'dominance'))
-        self.dominance_rolling: _1m1w1y24hPattern2 = _1m1w1y24hPattern2(client, _m(acc, 'dominance'))
-        self.rewards: BaseCumulativeSumPattern = BaseCumulativeSumPattern(client, _m(acc, 'rewards'))
-
 class BtcCentsSatsUsdPattern:
     """Pattern struct for repeated tree structure."""
     
@@ -2819,6 +2839,14 @@ class BaseCumulativePattern:
         self.base: BtcCentsSatsUsdPattern = BtcCentsSatsUsdPattern(client, acc)
         self.cumulative: BtcCentsSatsUsdPattern = BtcCentsSatsUsdPattern(client, _m(acc, 'cumulative'))
 
+class BlocksDominancePattern:
+    """Pattern struct for repeated tree structure."""
+    
+    def __init__(self, client: BrkClientBase, acc: str):
+        """Create pattern node with accumulated metric name."""
+        self.blocks_mined: CumulativeHeightPattern[StoredU32] = CumulativeHeightPattern(client, _m(acc, 'blocks_mined'))
+        self.dominance: BpsPercentRatioPattern = BpsPercentRatioPattern(client, _m(acc, 'dominance'))
+
 class BpsRatioPattern:
     """Pattern struct for repeated tree structure."""
     
@@ -3964,179 +3992,185 @@ class MetricsTree_Market:
         self.dca: MetricsTree_Market_Dca = MetricsTree_Market_Dca(client)
         self.indicators: MetricsTree_Market_Indicators = MetricsTree_Market_Indicators(client)
 
-class MetricsTree_Pools_Vecs:
+class MetricsTree_Pools_Major:
     """Metrics tree node."""
     
     def __init__(self, client: BrkClientBase, base_path: str = ''):
-        self.unknown: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'unknown')
-        self.blockfills: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'blockfills')
-        self.ultimuspool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'ultimuspool')
-        self.terrapool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'terrapool')
-        self.luxor: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'luxor')
-        self.onethash: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'onethash')
-        self.btccom: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btccom')
-        self.bitfarms: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitfarms')
-        self.huobipool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'huobipool')
-        self.wayicn: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'wayicn')
-        self.canoepool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'canoepool')
-        self.btctop: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btctop')
-        self.bitcoincom: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitcoincom')
-        self.pool175btc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'pool175btc')
-        self.gbminers: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'gbminers')
-        self.axbt: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'axbt')
-        self.asicminer: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'asicminer')
-        self.bitminter: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitminter')
-        self.bitcoinrussia: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitcoinrussia')
-        self.btcserv: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btcserv')
-        self.simplecoinus: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'simplecoinus')
-        self.btcguild: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btcguild')
-        self.eligius: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'eligius')
-        self.ozcoin: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'ozcoin')
-        self.eclipsemc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'eclipsemc')
-        self.maxbtc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'maxbtc')
-        self.triplemining: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'triplemining')
-        self.coinlab: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'coinlab')
-        self.pool50btc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'pool50btc')
-        self.ghashio: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'ghashio')
-        self.stminingcorp: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'stminingcorp')
-        self.bitparking: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitparking')
-        self.mmpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'mmpool')
-        self.polmine: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'polmine')
-        self.kncminer: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'kncminer')
-        self.bitalo: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitalo')
-        self.f2pool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'f2pool')
-        self.hhtt: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'hhtt')
-        self.megabigpower: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'megabigpower')
-        self.mtred: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'mtred')
-        self.nmcbit: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'nmcbit')
-        self.yourbtcnet: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'yourbtcnet')
-        self.givemecoins: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'givemecoins')
-        self.braiinspool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'braiinspool')
-        self.antpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'antpool')
-        self.multicoinco: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'multicoinco')
-        self.bcpoolio: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bcpoolio')
-        self.cointerra: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'cointerra')
-        self.kanopool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'kanopool')
-        self.solock: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'solock')
-        self.ckpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'ckpool')
-        self.nicehash: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'nicehash')
-        self.bitclub: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitclub')
-        self.bitcoinaffiliatenetwork: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitcoinaffiliatenetwork')
-        self.btcc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btcc')
-        self.bwpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bwpool')
-        self.exxbw: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'exxbw')
-        self.bitsolo: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitsolo')
-        self.bitfury: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitfury')
-        self.twentyoneinc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'twentyoneinc')
-        self.digitalbtc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'digitalbtc')
-        self.eightbaochi: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'eightbaochi')
-        self.mybtccoinpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'mybtccoinpool')
-        self.tbdice: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'tbdice')
-        self.hashpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'hashpool')
-        self.nexious: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'nexious')
-        self.bravomining: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bravomining')
-        self.hotpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'hotpool')
-        self.okexpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'okexpool')
-        self.bcmonster: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bcmonster')
-        self.onehash: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'onehash')
-        self.bixin: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bixin')
-        self.tatmaspool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'tatmaspool')
-        self.viabtc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'viabtc')
-        self.connectbtc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'connectbtc')
-        self.batpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'batpool')
-        self.waterhole: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'waterhole')
-        self.dcexploration: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'dcexploration')
-        self.dcex: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'dcex')
-        self.btpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btpool')
-        self.fiftyeightcoin: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'fiftyeightcoin')
-        self.bitcoinindia: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitcoinindia')
-        self.shawnp0wers: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'shawnp0wers')
-        self.phashio: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'phashio')
-        self.rigpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'rigpool')
-        self.haozhuzhu: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'haozhuzhu')
-        self.sevenpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'sevenpool')
-        self.miningkings: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'miningkings')
-        self.hashbx: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'hashbx')
-        self.dpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'dpool')
-        self.rawpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'rawpool')
-        self.haominer: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'haominer')
-        self.helix: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'helix')
-        self.bitcoinukraine: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitcoinukraine')
-        self.poolin: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'poolin')
-        self.secretsuperstar: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'secretsuperstar')
-        self.tigerpoolnet: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'tigerpoolnet')
-        self.sigmapoolcom: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'sigmapoolcom')
-        self.okpooltop: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'okpooltop')
-        self.hummerpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'hummerpool')
-        self.tangpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'tangpool')
-        self.bytepool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bytepool')
-        self.spiderpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'spiderpool')
-        self.novablock: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'novablock')
-        self.miningcity: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'miningcity')
-        self.binancepool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'binancepool')
-        self.minerium: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'minerium')
-        self.lubiancom: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'lubiancom')
-        self.okkong: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'okkong')
-        self.aaopool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'aaopool')
-        self.emcdpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'emcdpool')
-        self.foundryusa: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'foundryusa')
-        self.sbicrypto: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'sbicrypto')
-        self.arkpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'arkpool')
-        self.purebtccom: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'purebtccom')
-        self.marapool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'marapool')
-        self.kucoinpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'kucoinpool')
-        self.entrustcharitypool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'entrustcharitypool')
-        self.okminer: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'okminer')
-        self.titan: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'titan')
-        self.pegapool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'pegapool')
-        self.btcnuggets: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btcnuggets')
-        self.cloudhashing: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'cloudhashing')
-        self.digitalxmintsy: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'digitalxmintsy')
-        self.telco214: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'telco214')
-        self.btcpoolparty: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btcpoolparty')
-        self.multipool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'multipool')
-        self.transactioncoinmining: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'transactioncoinmining')
-        self.btcdig: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btcdig')
-        self.trickysbtcpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'trickysbtcpool')
-        self.btcmp: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btcmp')
-        self.eobot: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'eobot')
-        self.unomp: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'unomp')
-        self.patels: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'patels')
-        self.gogreenlight: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'gogreenlight')
-        self.bitcoinindiapool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitcoinindiapool')
-        self.ekanembtc: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'ekanembtc')
-        self.canoe: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'canoe')
-        self.tiger: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'tiger')
-        self.onem1x: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'onem1x')
-        self.zulupool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'zulupool')
-        self.secpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'secpool')
-        self.ocean: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'ocean')
-        self.whitepool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'whitepool')
-        self.wiz: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'wiz')
-        self.wk057: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'wk057')
-        self.futurebitapollosolo: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'futurebitapollosolo')
-        self.carbonnegative: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'carbonnegative')
-        self.portlandhodl: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'portlandhodl')
-        self.phoenix: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'phoenix')
-        self.neopool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'neopool')
-        self.maxipool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'maxipool')
-        self.bitfufupool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'bitfufupool')
-        self.gdpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'gdpool')
-        self.miningdutch: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'miningdutch')
-        self.publicpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'publicpool')
-        self.miningsquared: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'miningsquared')
-        self.innopolistech: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'innopolistech')
-        self.btclab: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'btclab')
-        self.parasite: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'parasite')
-        self.redrockpool: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'redrockpool')
-        self.est3lar: BlocksDominanceRewardsPattern = BlocksDominanceRewardsPattern(client, 'est3lar')
+        self.unknown: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'unknown')
+        self.ultimuspool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'ultimuspool')
+        self.terrapool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'terrapool')
+        self.luxor: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'luxor')
+        self.onethash: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'onethash')
+        self.btccom: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'btccom')
+        self.huobipool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'huobipool')
+        self.wayicn: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'wayicn')
+        self.canoepool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'canoepool')
+        self.btctop: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'btctop')
+        self.bitcoincom: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitcoincom')
+        self.gbminers: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'gbminers')
+        self.asicminer: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'asicminer')
+        self.bitminter: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitminter')
+        self.bitcoinrussia: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitcoinrussia')
+        self.btcguild: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'btcguild')
+        self.eligius: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'eligius')
+        self.ozcoin: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'ozcoin')
+        self.eclipsemc: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'eclipsemc')
+        self.maxbtc: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'maxbtc')
+        self.triplemining: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'triplemining')
+        self.coinlab: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'coinlab')
+        self.pool50btc: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'pool50btc')
+        self.ghashio: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'ghashio')
+        self.bitparking: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitparking')
+        self.polmine: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'polmine')
+        self.kncminer: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'kncminer')
+        self.f2pool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'f2pool')
+        self.hhtt: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'hhtt')
+        self.megabigpower: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'megabigpower')
+        self.nmcbit: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'nmcbit')
+        self.yourbtcnet: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'yourbtcnet')
+        self.braiinspool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'braiinspool')
+        self.antpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'antpool')
+        self.kanopool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'kanopool')
+        self.solock: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'solock')
+        self.nicehash: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'nicehash')
+        self.bitclub: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitclub')
+        self.bitcoinaffiliatenetwork: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitcoinaffiliatenetwork')
+        self.btcc: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'btcc')
+        self.bwpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bwpool')
+        self.exxbw: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'exxbw')
+        self.bitfury: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitfury')
+        self.digitalbtc: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'digitalbtc')
+        self.okexpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'okexpool')
+        self.bixin: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bixin')
+        self.tatmaspool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'tatmaspool')
+        self.viabtc: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'viabtc')
+        self.connectbtc: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'connectbtc')
+        self.batpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'batpool')
+        self.btpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'btpool')
+        self.fiftyeightcoin: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'fiftyeightcoin')
+        self.bitcoinindia: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bitcoinindia')
+        self.dpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'dpool')
+        self.poolin: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'poolin')
+        self.secretsuperstar: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'secretsuperstar')
+        self.tigerpoolnet: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'tigerpoolnet')
+        self.sigmapoolcom: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'sigmapoolcom')
+        self.okpooltop: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'okpooltop')
+        self.tangpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'tangpool')
+        self.bytepool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'bytepool')
+        self.spiderpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'spiderpool')
+        self.novablock: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'novablock')
+        self.binancepool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'binancepool')
+        self.lubiancom: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'lubiancom')
+        self.okkong: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'okkong')
+        self.emcdpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'emcdpool')
+        self.foundryusa: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'foundryusa')
+        self.sbicrypto: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'sbicrypto')
+        self.marapool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'marapool')
+        self.kucoinpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'kucoinpool')
+        self.pegapool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'pegapool')
+        self.secpool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'secpool')
+        self.ocean: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'ocean')
+        self.whitepool: _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern = _1m1w1y24hBaseBpsCumulativeHeightPercentRatioSumPattern(client, 'whitepool')
+
+class MetricsTree_Pools_Minor:
+    """Metrics tree node."""
+    
+    def __init__(self, client: BrkClientBase, base_path: str = ''):
+        self.blockfills: BlocksDominancePattern = BlocksDominancePattern(client, 'blockfills')
+        self.bitfarms: BlocksDominancePattern = BlocksDominancePattern(client, 'bitfarms')
+        self.pool175btc: BlocksDominancePattern = BlocksDominancePattern(client, 'pool175btc')
+        self.axbt: BlocksDominancePattern = BlocksDominancePattern(client, 'axbt')
+        self.btcserv: BlocksDominancePattern = BlocksDominancePattern(client, 'btcserv')
+        self.simplecoinus: BlocksDominancePattern = BlocksDominancePattern(client, 'simplecoinus')
+        self.stminingcorp: BlocksDominancePattern = BlocksDominancePattern(client, 'stminingcorp')
+        self.mmpool: BlocksDominancePattern = BlocksDominancePattern(client, 'mmpool')
+        self.bitalo: BlocksDominancePattern = BlocksDominancePattern(client, 'bitalo')
+        self.mtred: BlocksDominancePattern = BlocksDominancePattern(client, 'mtred')
+        self.givemecoins: BlocksDominancePattern = BlocksDominancePattern(client, 'givemecoins')
+        self.multicoinco: BlocksDominancePattern = BlocksDominancePattern(client, 'multicoinco')
+        self.bcpoolio: BlocksDominancePattern = BlocksDominancePattern(client, 'bcpoolio')
+        self.cointerra: BlocksDominancePattern = BlocksDominancePattern(client, 'cointerra')
+        self.ckpool: BlocksDominancePattern = BlocksDominancePattern(client, 'ckpool')
+        self.bitsolo: BlocksDominancePattern = BlocksDominancePattern(client, 'bitsolo')
+        self.twentyoneinc: BlocksDominancePattern = BlocksDominancePattern(client, 'twentyoneinc')
+        self.eightbaochi: BlocksDominancePattern = BlocksDominancePattern(client, 'eightbaochi')
+        self.mybtccoinpool: BlocksDominancePattern = BlocksDominancePattern(client, 'mybtccoinpool')
+        self.tbdice: BlocksDominancePattern = BlocksDominancePattern(client, 'tbdice')
+        self.hashpool: BlocksDominancePattern = BlocksDominancePattern(client, 'hashpool')
+        self.nexious: BlocksDominancePattern = BlocksDominancePattern(client, 'nexious')
+        self.bravomining: BlocksDominancePattern = BlocksDominancePattern(client, 'bravomining')
+        self.hotpool: BlocksDominancePattern = BlocksDominancePattern(client, 'hotpool')
+        self.bcmonster: BlocksDominancePattern = BlocksDominancePattern(client, 'bcmonster')
+        self.onehash: BlocksDominancePattern = BlocksDominancePattern(client, 'onehash')
+        self.waterhole: BlocksDominancePattern = BlocksDominancePattern(client, 'waterhole')
+        self.dcexploration: BlocksDominancePattern = BlocksDominancePattern(client, 'dcexploration')
+        self.dcex: BlocksDominancePattern = BlocksDominancePattern(client, 'dcex')
+        self.shawnp0wers: BlocksDominancePattern = BlocksDominancePattern(client, 'shawnp0wers')
+        self.phashio: BlocksDominancePattern = BlocksDominancePattern(client, 'phashio')
+        self.rigpool: BlocksDominancePattern = BlocksDominancePattern(client, 'rigpool')
+        self.haozhuzhu: BlocksDominancePattern = BlocksDominancePattern(client, 'haozhuzhu')
+        self.sevenpool: BlocksDominancePattern = BlocksDominancePattern(client, 'sevenpool')
+        self.miningkings: BlocksDominancePattern = BlocksDominancePattern(client, 'miningkings')
+        self.hashbx: BlocksDominancePattern = BlocksDominancePattern(client, 'hashbx')
+        self.rawpool: BlocksDominancePattern = BlocksDominancePattern(client, 'rawpool')
+        self.haominer: BlocksDominancePattern = BlocksDominancePattern(client, 'haominer')
+        self.helix: BlocksDominancePattern = BlocksDominancePattern(client, 'helix')
+        self.bitcoinukraine: BlocksDominancePattern = BlocksDominancePattern(client, 'bitcoinukraine')
+        self.hummerpool: BlocksDominancePattern = BlocksDominancePattern(client, 'hummerpool')
+        self.miningcity: BlocksDominancePattern = BlocksDominancePattern(client, 'miningcity')
+        self.minerium: BlocksDominancePattern = BlocksDominancePattern(client, 'minerium')
+        self.aaopool: BlocksDominancePattern = BlocksDominancePattern(client, 'aaopool')
+        self.arkpool: BlocksDominancePattern = BlocksDominancePattern(client, 'arkpool')
+        self.purebtccom: BlocksDominancePattern = BlocksDominancePattern(client, 'purebtccom')
+        self.entrustcharitypool: BlocksDominancePattern = BlocksDominancePattern(client, 'entrustcharitypool')
+        self.okminer: BlocksDominancePattern = BlocksDominancePattern(client, 'okminer')
+        self.titan: BlocksDominancePattern = BlocksDominancePattern(client, 'titan')
+        self.btcnuggets: BlocksDominancePattern = BlocksDominancePattern(client, 'btcnuggets')
+        self.cloudhashing: BlocksDominancePattern = BlocksDominancePattern(client, 'cloudhashing')
+        self.digitalxmintsy: BlocksDominancePattern = BlocksDominancePattern(client, 'digitalxmintsy')
+        self.telco214: BlocksDominancePattern = BlocksDominancePattern(client, 'telco214')
+        self.btcpoolparty: BlocksDominancePattern = BlocksDominancePattern(client, 'btcpoolparty')
+        self.multipool: BlocksDominancePattern = BlocksDominancePattern(client, 'multipool')
+        self.transactioncoinmining: BlocksDominancePattern = BlocksDominancePattern(client, 'transactioncoinmining')
+        self.btcdig: BlocksDominancePattern = BlocksDominancePattern(client, 'btcdig')
+        self.trickysbtcpool: BlocksDominancePattern = BlocksDominancePattern(client, 'trickysbtcpool')
+        self.btcmp: BlocksDominancePattern = BlocksDominancePattern(client, 'btcmp')
+        self.eobot: BlocksDominancePattern = BlocksDominancePattern(client, 'eobot')
+        self.unomp: BlocksDominancePattern = BlocksDominancePattern(client, 'unomp')
+        self.patels: BlocksDominancePattern = BlocksDominancePattern(client, 'patels')
+        self.gogreenlight: BlocksDominancePattern = BlocksDominancePattern(client, 'gogreenlight')
+        self.bitcoinindiapool: BlocksDominancePattern = BlocksDominancePattern(client, 'bitcoinindiapool')
+        self.ekanembtc: BlocksDominancePattern = BlocksDominancePattern(client, 'ekanembtc')
+        self.canoe: BlocksDominancePattern = BlocksDominancePattern(client, 'canoe')
+        self.tiger: BlocksDominancePattern = BlocksDominancePattern(client, 'tiger')
+        self.onem1x: BlocksDominancePattern = BlocksDominancePattern(client, 'onem1x')
+        self.zulupool: BlocksDominancePattern = BlocksDominancePattern(client, 'zulupool')
+        self.wiz: BlocksDominancePattern = BlocksDominancePattern(client, 'wiz')
+        self.wk057: BlocksDominancePattern = BlocksDominancePattern(client, 'wk057')
+        self.futurebitapollosolo: BlocksDominancePattern = BlocksDominancePattern(client, 'futurebitapollosolo')
+        self.carbonnegative: BlocksDominancePattern = BlocksDominancePattern(client, 'carbonnegative')
+        self.portlandhodl: BlocksDominancePattern = BlocksDominancePattern(client, 'portlandhodl')
+        self.phoenix: BlocksDominancePattern = BlocksDominancePattern(client, 'phoenix')
+        self.neopool: BlocksDominancePattern = BlocksDominancePattern(client, 'neopool')
+        self.maxipool: BlocksDominancePattern = BlocksDominancePattern(client, 'maxipool')
+        self.bitfufupool: BlocksDominancePattern = BlocksDominancePattern(client, 'bitfufupool')
+        self.gdpool: BlocksDominancePattern = BlocksDominancePattern(client, 'gdpool')
+        self.miningdutch: BlocksDominancePattern = BlocksDominancePattern(client, 'miningdutch')
+        self.publicpool: BlocksDominancePattern = BlocksDominancePattern(client, 'publicpool')
+        self.miningsquared: BlocksDominancePattern = BlocksDominancePattern(client, 'miningsquared')
+        self.innopolistech: BlocksDominancePattern = BlocksDominancePattern(client, 'innopolistech')
+        self.btclab: BlocksDominancePattern = BlocksDominancePattern(client, 'btclab')
+        self.parasite: BlocksDominancePattern = BlocksDominancePattern(client, 'parasite')
+        self.redrockpool: BlocksDominancePattern = BlocksDominancePattern(client, 'redrockpool')
+        self.est3lar: BlocksDominancePattern = BlocksDominancePattern(client, 'est3lar')
 
 class MetricsTree_Pools:
     """Metrics tree node."""
     
     def __init__(self, client: BrkClientBase, base_path: str = ''):
         self.height_to_pool: MetricPattern18[PoolSlug] = MetricPattern18(client, 'pool')
-        self.vecs: MetricsTree_Pools_Vecs = MetricsTree_Pools_Vecs(client)
+        self.major: MetricsTree_Pools_Major = MetricsTree_Pools_Major(client)
+        self.minor: MetricsTree_Pools_Minor = MetricsTree_Pools_Minor(client)
 
 class MetricsTree_Prices_Split_Close:
     """Metrics tree node."""
@@ -4214,15 +4248,15 @@ class MetricsTree_Distribution_UtxoCohorts_All_Relative:
     """Metrics tree node."""
     
     def __init__(self, client: BrkClientBase, base_path: str = ''):
-        self.invested_capital_in_profit_rel_to_realized_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'invested_capital_in_profit_rel_to_realized_cap')
-        self.invested_capital_in_loss_rel_to_realized_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'invested_capital_in_loss_rel_to_realized_cap')
-        self.supply_in_profit_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'supply_in_profit_rel_to_own_supply')
-        self.supply_in_loss_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'supply_in_loss_rel_to_own_supply')
         self.unrealized_profit_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'unrealized_profit_rel_to_market_cap')
         self.unrealized_loss_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'unrealized_loss_rel_to_market_cap')
         self.net_unrealized_pnl_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'net_unrealized_pnl_rel_to_market_cap')
         self.neg_unrealized_loss_rel_to_market_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'neg_unrealized_loss_rel_to_market_cap')
         self.nupl: MetricPattern1[StoredF32] = MetricPattern1(client, 'nupl')
+        self.invested_capital_in_profit_rel_to_realized_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'invested_capital_in_profit_rel_to_realized_cap')
+        self.invested_capital_in_loss_rel_to_realized_cap: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'invested_capital_in_loss_rel_to_realized_cap')
+        self.supply_in_profit_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'supply_in_profit_rel_to_own_supply')
+        self.supply_in_loss_rel_to_own_supply: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'supply_in_loss_rel_to_own_supply')
         self.unrealized_profit_rel_to_own_gross_pnl: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'unrealized_profit_rel_to_own_gross_pnl')
         self.unrealized_loss_rel_to_own_gross_pnl: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'unrealized_loss_rel_to_own_gross_pnl')
         self.neg_unrealized_loss_rel_to_own_gross_pnl: BpsPercentRatioPattern = BpsPercentRatioPattern(client, 'neg_unrealized_loss_rel_to_own_gross_pnl')