global: snap

crates/brk_computer/src/distribution/addr/exposed/mod.rs

@@ -37,22 +37,25 @@ mod count;
 mod supply;
 
 pub use count::{AddrTypeToExposedAddrCount, ExposedAddrCountsVecs};
-pub use supply::{AddrTypeToExposedAddrSupply, ExposedAddrSupplyVecs};
+pub use supply::{AddrTypeToExposedSupply, ExposedAddrSupplyVecs, ExposedSupplyShareVecs};
 
+use brk_cohort::ByAddrType;
 use brk_error::Result;
 use brk_traversable::Traversable;
-use brk_types::{Indexes, Version};
+use brk_types::{Height, Indexes, Sats, Version};
 use rayon::prelude::*;
-use vecdb::{AnyStoredVec, Database, Exit, Rw, StorageMode};
+use vecdb::{AnyStoredVec, Database, Exit, ReadableVec, Rw, StorageMode};
 
-use crate::{indexes, prices};
+use crate::{indexes, internal::RatioSatsBp16, prices};
 
 /// Top-level container for all exposed address tracking: counts (funded +
-/// total) plus the funded supply.
+/// total), the funded supply, and share of supply.
 #[derive(Traversable)]
 pub struct ExposedAddrVecs<M: StorageMode = Rw> {
     pub count: ExposedAddrCountsVecs<M>,
     pub supply: ExposedAddrSupplyVecs<M>,
+    #[traversable(wrap = "supply", rename = "share")]
+    pub supply_share: ExposedSupplyShareVecs<M>,
 }
 
 impl ExposedAddrVecs {
@@ -64,6 +67,7 @@ impl ExposedAddrVecs {
         Ok(Self {
             count: ExposedAddrCountsVecs::forced_import(db, version, indexes)?,
             supply: ExposedAddrSupplyVecs::forced_import(db, version, indexes)?,
+            supply_share: ExposedSupplyShareVecs::forced_import(db, version, indexes)?,
         })
     }
 
@@ -84,6 +88,7 @@ impl ExposedAddrVecs {
     pub(crate) fn reset_height(&mut self) -> Result<()> {
         self.count.reset_height()?;
         self.supply.reset_height()?;
+        self.supply_share.reset_height()?;
         Ok(())
     }
 
@@ -91,11 +96,39 @@ impl ExposedAddrVecs {
         &mut self,
         starting_indexes: &Indexes,
         prices: &prices::Vecs,
+        all_supply_sats: &impl ReadableVec<Height, Sats>,
+        type_supply_sats: &ByAddrType<&impl ReadableVec<Height, Sats>>,
         exit: &Exit,
     ) -> Result<()> {
         self.count.compute_rest(starting_indexes, exit)?;
         self.supply
             .compute_rest(starting_indexes.height, prices, exit)?;
+
+        let max_from = starting_indexes.height;
+
+        self.supply_share
+            .all
+            .compute_binary::<Sats, Sats, RatioSatsBp16>(
+                max_from,
+                &self.supply.all.sats.height,
+                all_supply_sats,
+                exit,
+            )?;
+
+        for ((_, share), ((_, exposed), (_, denom))) in self
+            .supply_share
+            .by_addr_type
+            .iter_mut()
+            .zip(self.supply.by_addr_type.iter().zip(type_supply_sats.iter()))
+        {
+            share.compute_binary::<Sats, Sats, RatioSatsBp16>(
+                max_from,
+                &exposed.sats.height,
+                *denom,
+                exit,
+            )?;
+        }
+
         Ok(())
     }
 }

crates/brk_computer/src/distribution/addr/exposed/supply/mod.rs

@@ -3,8 +3,10 @@
 //! aggregated `all`. See the parent [`super`] module for the definition of
 //! "exposed" and how it varies by address type.
 
+mod share;
 mod state;
 mod vecs;
 
-pub use state::AddrTypeToExposedAddrSupply;
+pub use share::ExposedSupplyShareVecs;
+pub use state::AddrTypeToExposedSupply;
 pub use vecs::ExposedAddrSupplyVecs;

crates/brk_computer/src/distribution/addr/exposed/supply/share.rs

@@ -0,0 +1,36 @@
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{BasisPoints16, Version};
+use derive_more::{Deref, DerefMut};
+use vecdb::{Database, Rw, StorageMode};
+
+use crate::{
+    indexes,
+    internal::{PercentPerBlock, WithAddrTypes},
+};
+
+/// Share of exposed supply relative to total supply.
+///
+/// - `all`: exposed_supply / circulating_supply
+/// - Per-type: type's exposed_supply / type's total supply
+#[derive(Deref, DerefMut, Traversable)]
+pub struct ExposedSupplyShareVecs<M: StorageMode = Rw>(
+    #[traversable(flatten)] pub WithAddrTypes<PercentPerBlock<BasisPoints16, M>>,
+);
+
+impl ExposedSupplyShareVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self(
+            WithAddrTypes::<PercentPerBlock<BasisPoints16>>::forced_import(
+                db,
+                "exposed_supply_share",
+                version,
+                indexes,
+            )?,
+        ))
+    }
+}

crates/brk_computer/src/distribution/addr/exposed/supply/state.rs

@@ -1,5 +1,5 @@
 use brk_cohort::ByAddrType;
-use brk_types::Height;
+use brk_types::{Height, Sats};
 use derive_more::{Deref, DerefMut};
 use vecdb::ReadableVec;
 
@@ -10,22 +10,21 @@ use super::vecs::ExposedAddrSupplyVecs;
 /// Runtime running counter for the total balance (sats) held by funded
 /// exposed addresses, per address type.
 #[derive(Debug, Default, Deref, DerefMut)]
-pub struct AddrTypeToExposedAddrSupply(ByAddrType<u64>);
+pub struct AddrTypeToExposedSupply(ByAddrType<Sats>);
 
-impl AddrTypeToExposedAddrSupply {
+impl AddrTypeToExposedSupply {
     #[inline]
-    pub(crate) fn sum(&self) -> u64 {
-        self.0.values().sum()
+    pub(crate) fn sum(&self) -> Sats {
+        self.0.values().copied().sum()
     }
 }
 
-impl From<(&ExposedAddrSupplyVecs, Height)> for AddrTypeToExposedAddrSupply {
+impl From<(&ExposedAddrSupplyVecs, Height)> for AddrTypeToExposedSupply {
     #[inline]
     fn from((vecs, starting_height): (&ExposedAddrSupplyVecs, Height)) -> Self {
         if let Some(prev_height) = starting_height.decremented() {
-            let read = |v: &AmountPerBlock| -> u64 {
-                u64::from(v.sats.height.collect_one(prev_height).unwrap())
-            };
+            let read =
+                |v: &AmountPerBlock| -> Sats { v.sats.height.collect_one(prev_height).unwrap() };
             Self(ByAddrType {
                 p2pk65: read(&vecs.by_addr_type.p2pk65),
                 p2pk33: read(&vecs.by_addr_type.p2pk33),

crates/brk_computer/src/distribution/addr/exposed/supply/vecs.rs

@@ -26,7 +26,7 @@ impl ExposedAddrSupplyVecs {
     ) -> Result<Self> {
         Ok(Self(WithAddrTypes::<AmountPerBlock>::forced_import(
             db,
-            "exposed_addr_supply",
+            "exposed_supply",
             version,
             indexes,
         )?))

crates/brk_computer/src/distribution/addr/mod.rs

@@ -13,13 +13,9 @@ pub use activity::{AddrActivityVecs, AddrTypeToActivityCounts};
 pub use addr_count::{AddrCountsVecs, AddrTypeToAddrCount};
 pub use data::AddrsDataVecs;
 pub use delta::DeltaVecs;
-pub use exposed::{
-    AddrTypeToExposedAddrCount, AddrTypeToExposedAddrSupply, ExposedAddrVecs,
-};
+pub use exposed::{AddrTypeToExposedAddrCount, AddrTypeToExposedSupply, ExposedAddrVecs,};
 pub use indexes::AnyAddrIndexesVecs;
 pub use new_addr_count::NewAddrCountVecs;
-pub use reused::{
-    AddrTypeToReusedAddrCount, AddrTypeToReusedAddrEventCount, ReusedAddrVecs,
-};
+pub use reused::{AddrTypeToReusedAddrCount, AddrTypeToReusedAddrEventCount, ReusedAddrVecs};
 pub use total_addr_count::TotalAddrCountVecs;
 pub use type_map::{AddrTypeToTypeIndexMap, AddrTypeToVec, HeightToAddrTypeToVec};