global: big snapshot

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

@@ -1,22 +1,18 @@
-use brk_cohort::ByAddrType;
 use brk_traversable::Traversable;
 use brk_types::{BasisPointsSigned32, StoredI64, StoredU64, Version};
+use derive_more::{Deref, DerefMut};
 
 use crate::{
     indexes,
     internal::{LazyRollingDeltasFromHeight, WindowStartVec, Windows},
 };
 
-use super::AddrCountsVecs;
+use super::{AddrCountsVecs, WithAddrTypes};
 
 type AddrDelta = LazyRollingDeltasFromHeight<StoredU64, StoredI64, BasisPointsSigned32>;
 
-#[derive(Clone, Traversable)]
-pub struct DeltaVecs {
-    pub all: AddrDelta,
-    #[traversable(flatten)]
-    pub by_addr_type: ByAddrType<AddrDelta>,
-}
+#[derive(Clone, Deref, DerefMut, Traversable)]
+pub struct DeltaVecs(#[traversable(flatten)] pub WithAddrTypes<AddrDelta>);
 
 impl DeltaVecs {
     pub(crate) fn new(
@@ -45,6 +41,6 @@ impl DeltaVecs {
             )
         });
 
-        Self { all, by_addr_type }
+        Self(WithAddrTypes { all, by_addr_type })
     }
 }

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

@@ -0,0 +1,74 @@
+//! Exposed address count tracking — running counters of how many addresses
+//! are currently in (or have ever been in) the exposed set, per address type
+//! plus an aggregated `all`. See the parent [`super`] module for the
+//! definition of "exposed" and how it varies by address type.
+
+mod state;
+mod vecs;
+
+pub use state::AddrTypeToExposedAddrCount;
+pub use vecs::ExposedAddrCountAllVecs;
+
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Indexes, Version};
+use rayon::prelude::*;
+use vecdb::{AnyStoredVec, Database, Exit, Rw, StorageMode};
+
+use crate::indexes;
+
+/// Exposed address counts: funded (currently at-risk) and total (ever at-risk).
+#[derive(Traversable)]
+pub struct ExposedAddrCountsVecs<M: StorageMode = Rw> {
+    pub funded: ExposedAddrCountAllVecs<M>,
+    pub total: ExposedAddrCountAllVecs<M>,
+}
+
+impl ExposedAddrCountsVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self {
+            funded: ExposedAddrCountAllVecs::forced_import(
+                db,
+                "exposed_addr_count",
+                version,
+                indexes,
+            )?,
+            total: ExposedAddrCountAllVecs::forced_import(
+                db,
+                "total_exposed_addr_count",
+                version,
+                indexes,
+            )?,
+        })
+    }
+
+    pub(crate) fn min_stateful_len(&self) -> usize {
+        self.funded
+            .min_stateful_len()
+            .min(self.total.min_stateful_len())
+    }
+
+    pub(crate) fn par_iter_height_mut(
+        &mut self,
+    ) -> impl ParallelIterator<Item = &mut dyn AnyStoredVec> {
+        self.funded
+            .par_iter_height_mut()
+            .chain(self.total.par_iter_height_mut())
+    }
+
+    pub(crate) fn reset_height(&mut self) -> Result<()> {
+        self.funded.reset_height()?;
+        self.total.reset_height()?;
+        Ok(())
+    }
+
+    pub(crate) fn compute_rest(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()> {
+        self.funded.compute_rest(starting_indexes, exit)?;
+        self.total.compute_rest(starting_indexes, exit)?;
+        Ok(())
+    }
+}

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

@@ -0,0 +1,42 @@
+use brk_cohort::ByAddrType;
+use brk_types::{Height, StoredU64};
+use derive_more::{Deref, DerefMut};
+use vecdb::ReadableVec;
+
+use crate::internal::PerBlock;
+
+use super::vecs::ExposedAddrCountAllVecs;
+
+/// Runtime counter for exposed address counts per address type.
+#[derive(Debug, Default, Deref, DerefMut)]
+pub struct AddrTypeToExposedAddrCount(ByAddrType<u64>);
+
+impl AddrTypeToExposedAddrCount {
+    #[inline]
+    pub(crate) fn sum(&self) -> u64 {
+        self.0.values().sum()
+    }
+}
+
+impl From<(&ExposedAddrCountAllVecs, Height)> for AddrTypeToExposedAddrCount {
+    #[inline]
+    fn from((vecs, starting_height): (&ExposedAddrCountAllVecs, Height)) -> Self {
+        if let Some(prev_height) = starting_height.decremented() {
+            let read = |v: &PerBlock<StoredU64>| -> u64 {
+                v.height.collect_one(prev_height).unwrap().into()
+            };
+            Self(ByAddrType {
+                p2pk65: read(&vecs.by_addr_type.p2pk65),
+                p2pk33: read(&vecs.by_addr_type.p2pk33),
+                p2pkh: read(&vecs.by_addr_type.p2pkh),
+                p2sh: read(&vecs.by_addr_type.p2sh),
+                p2wpkh: read(&vecs.by_addr_type.p2wpkh),
+                p2wsh: read(&vecs.by_addr_type.p2wsh),
+                p2tr: read(&vecs.by_addr_type.p2tr),
+                p2a: read(&vecs.by_addr_type.p2a),
+            })
+        } else {
+            Default::default()
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{StoredU64, Version};
+use derive_more::{Deref, DerefMut};
+use vecdb::{Database, Rw, StorageMode};
+
+use crate::{
+    distribution::addr::WithAddrTypes,
+    indexes,
+    internal::PerBlock,
+};
+
+/// Exposed address count (`all` + per-type) for a single variant (funded or total).
+#[derive(Deref, DerefMut, Traversable)]
+pub struct ExposedAddrCountAllVecs<M: StorageMode = Rw>(
+    #[traversable(flatten)] pub WithAddrTypes<PerBlock<StoredU64, M>>,
+);
+
+impl ExposedAddrCountAllVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self(WithAddrTypes::<PerBlock<StoredU64>>::forced_import(
+            db, name, version, indexes,
+        )?))
+    }
+}

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

@@ -0,0 +1,95 @@
+//! Exposed address tracking (quantum / pubkey-exposure sense).
+//!
+//! An address is "exposed" once its public key is in the blockchain. Once
+//! exposed, any funds at that address are at cryptographic risk (e.g. from
+//! a quantum attacker capable of recovering the private key from the pubkey).
+//!
+//! When the pubkey gets exposed depends on the address type:
+//!
+//! - **P2PK33, P2PK65, P2TR**: the pubkey (or P2TR's tweaked output key) is
+//!   directly in the locking script of the funding output. These addresses are
+//!   exposed the moment they receive any funds.
+//! - **P2PKH, P2SH, P2WPKH, P2WSH**: the locking script contains a hash of
+//!   the pubkey/script. The pubkey is only revealed when spending. Note that
+//!   even the spending tx itself exposes the pubkey while the address still
+//!   holds funds — during the mempool window between broadcast and confirmation,
+//!   the pubkey is visible while the UTXO being spent is still unspent on-chain.
+//!   So every spent address of these types has had at least one moment with
+//!   funds at quantum risk.
+//! - **P2A**: anyone-can-spend, no pubkey at all. Excluded from both counters.
+//!
+//! Formally, with `is_funding_exposed` = `output_type.pubkey_exposed_at_funding()`:
+//! - `funded` (count): `(utxo_count > 0) AND (is_funding_exposed OR spent_txo_count >= 1)`
+//! - `total` (count): `(is_funding_exposed AND ever received) OR spent_txo_count >= 1`
+//! - `supply` (sats): sum of balances of addresses currently in the funded set
+//!
+//! For P2PK/P2TR types this means `total ≡ total_addr_count` and
+//! `funded ≡ funded_addr_count` (every address of those types is exposed by
+//! virtue of existing). For P2PKH/P2SH/P2WPKH/P2WSH it's the strict subset of
+//! addresses that have been spent from. The aggregate `all` exposed counter
+//! sums these, giving "Bitcoin addresses currently with funds at quantum risk".
+//!
+//! All metrics are tracked as running counters and require no extra fields
+//! on the address data — they're maintained via delta detection in
+//! `process_received` and `process_sent`.
+
+mod count;
+mod supply;
+
+pub use count::{AddrTypeToExposedAddrCount, ExposedAddrCountsVecs};
+pub use supply::{AddrTypeToExposedAddrSupply, ExposedAddrSupplyVecs};
+
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Indexes, Version};
+use rayon::prelude::*;
+use vecdb::{AnyStoredVec, Database, Exit, Rw, StorageMode};
+
+use crate::indexes;
+
+/// Top-level container for all exposed address tracking: counts (funded +
+/// total) plus the funded supply.
+#[derive(Traversable)]
+pub struct ExposedAddrVecs<M: StorageMode = Rw> {
+    pub count: ExposedAddrCountsVecs<M>,
+    pub supply: ExposedAddrSupplyVecs<M>,
+}
+
+impl ExposedAddrVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self {
+            count: ExposedAddrCountsVecs::forced_import(db, version, indexes)?,
+            supply: ExposedAddrSupplyVecs::forced_import(db, version, indexes)?,
+        })
+    }
+
+    pub(crate) fn min_stateful_len(&self) -> usize {
+        self.count
+            .min_stateful_len()
+            .min(self.supply.min_stateful_len())
+    }
+
+    pub(crate) fn par_iter_height_mut(
+        &mut self,
+    ) -> impl ParallelIterator<Item = &mut dyn AnyStoredVec> {
+        self.count
+            .par_iter_height_mut()
+            .chain(self.supply.par_iter_height_mut())
+    }
+
+    pub(crate) fn reset_height(&mut self) -> Result<()> {
+        self.count.reset_height()?;
+        self.supply.reset_height()?;
+        Ok(())
+    }
+
+    pub(crate) fn compute_rest(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()> {
+        self.count.compute_rest(starting_indexes, exit)?;
+        self.supply.compute_rest(starting_indexes, exit)?;
+        Ok(())
+    }
+}

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

@@ -0,0 +1,10 @@
+//! Exposed address supply (sats) tracking — running sum of balances held by
+//! addresses currently in the funded exposed set, per address type plus an
+//! aggregated `all`. See the parent [`super`] module for the definition of
+//! "exposed" and how it varies by address type.
+
+mod state;
+mod vecs;
+
+pub use state::AddrTypeToExposedAddrSupply;
+pub use vecs::ExposedAddrSupplyVecs;

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

@@ -0,0 +1,43 @@
+use brk_cohort::ByAddrType;
+use brk_types::{Height, Sats};
+use derive_more::{Deref, DerefMut};
+use vecdb::ReadableVec;
+
+use crate::internal::PerBlock;
+
+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>);
+
+impl AddrTypeToExposedAddrSupply {
+    #[inline]
+    pub(crate) fn sum(&self) -> u64 {
+        self.0.values().sum()
+    }
+}
+
+impl From<(&ExposedAddrSupplyVecs, Height)> for AddrTypeToExposedAddrSupply {
+    #[inline]
+    fn from((vecs, starting_height): (&ExposedAddrSupplyVecs, Height)) -> Self {
+        if let Some(prev_height) = starting_height.decremented() {
+            let read = |v: &PerBlock<Sats>| -> u64 {
+                u64::from(v.height.collect_one(prev_height).unwrap())
+            };
+            Self(ByAddrType {
+                p2pk65: read(&vecs.by_addr_type.p2pk65),
+                p2pk33: read(&vecs.by_addr_type.p2pk33),
+                p2pkh: read(&vecs.by_addr_type.p2pkh),
+                p2sh: read(&vecs.by_addr_type.p2sh),
+                p2wpkh: read(&vecs.by_addr_type.p2wpkh),
+                p2wsh: read(&vecs.by_addr_type.p2wsh),
+                p2tr: read(&vecs.by_addr_type.p2tr),
+                p2a: read(&vecs.by_addr_type.p2a),
+            })
+        } else {
+            Default::default()
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Sats, Version};
+use derive_more::{Deref, DerefMut};
+use vecdb::{Database, Rw, StorageMode};
+
+use crate::{
+    distribution::addr::WithAddrTypes,
+    indexes,
+    internal::PerBlock,
+};
+
+/// Exposed address supply (sats) — `all` + per-address-type. Tracks the total
+/// balance held by addresses currently in the funded exposed set.
+#[derive(Deref, DerefMut, Traversable)]
+pub struct ExposedAddrSupplyVecs<M: StorageMode = Rw>(
+    #[traversable(flatten)] pub WithAddrTypes<PerBlock<Sats, M>>,
+);
+
+impl ExposedAddrSupplyVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self(WithAddrTypes::<PerBlock<Sats>>::forced_import(
+            db,
+            "exposed_addr_supply",
+            version,
+            indexes,
+        )?))
+    }
+}

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

@@ -2,16 +2,26 @@ mod activity;
 mod addr_count;
 mod data;
 mod delta;
+mod exposed;
 mod indexes;
 mod new_addr_count;
+mod reused;
 mod total_addr_count;
 mod type_map;
+mod with_addr_types;
 
 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 indexes::AnyAddrIndexesVecs;
 pub use new_addr_count::NewAddrCountVecs;
+pub use reused::{
+    AddrTypeToReusedAddrCount, AddrTypeToReusedAddrUseCount, ReusedAddrVecs,
+};
 pub use total_addr_count::TotalAddrCountVecs;
 pub use type_map::{AddrTypeToTypeIndexMap, AddrTypeToVec, HeightToAddrTypeToVec};
+pub use with_addr_types::WithAddrTypes;

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

@@ -1,7 +1,7 @@
-use brk_cohort::ByAddrType;
 use brk_error::Result;
 use brk_traversable::Traversable;
 use brk_types::{Height, StoredU64, Version};
+use derive_more::{Deref, DerefMut};
 use vecdb::{Database, Exit, Rw, StorageMode};
 
 use crate::{
@@ -9,15 +9,14 @@ use crate::{
     internal::{PerBlockCumulativeRolling, WindowStartVec, Windows},
 };
 
-use super::TotalAddrCountVecs;
+use super::{TotalAddrCountVecs, WithAddrTypes};
 
-/// New address count per block (global + per-type)
-#[derive(Traversable)]
-pub struct NewAddrCountVecs<M: StorageMode = Rw> {
-    pub all: PerBlockCumulativeRolling<StoredU64, StoredU64, M>,
+/// New address count per block (global + per-type).
+#[derive(Deref, DerefMut, Traversable)]
+pub struct NewAddrCountVecs<M: StorageMode = Rw>(
     #[traversable(flatten)]
-    pub by_addr_type: ByAddrType<PerBlockCumulativeRolling<StoredU64, StoredU64, M>>,
-}
+    pub WithAddrTypes<PerBlockCumulativeRolling<StoredU64, StoredU64, M>>,
+);
 
 impl NewAddrCountVecs {
     pub(crate) fn forced_import(
@@ -26,25 +25,11 @@ impl NewAddrCountVecs {
         indexes: &indexes::Vecs,
         cached_starts: &Windows<&WindowStartVec>,
     ) -> Result<Self> {
-        let all = PerBlockCumulativeRolling::forced_import(
-            db,
-            "new_addr_count",
-            version,
-            indexes,
-            cached_starts,
-        )?;
-
-        let by_addr_type = ByAddrType::new_with_name(|name| {
-            PerBlockCumulativeRolling::forced_import(
-                db,
-                &format!("{name}_new_addr_count"),
-                version,
-                indexes,
-                cached_starts,
-            )
-        })?;
-
-        Ok(Self { all, by_addr_type })
+        Ok(Self(WithAddrTypes::<
+            PerBlockCumulativeRolling<StoredU64, StoredU64>,
+        >::forced_import(
+            db, "new_addr_count", version, indexes, cached_starts
+        )?))
     }
 
     pub(crate) fn compute(
@@ -53,11 +38,12 @@ impl NewAddrCountVecs {
         total_addr_count: &TotalAddrCountVecs,
         exit: &Exit,
     ) -> Result<()> {
-        self.all.compute(max_from, exit, |height_vec| {
+        self.0.all.compute(max_from, exit, |height_vec| {
             Ok(height_vec.compute_change(max_from, &total_addr_count.all.height, 1, exit)?)
         })?;
 
         for ((_, new), (_, total)) in self
+            .0
             .by_addr_type
             .iter_mut()
             .zip(total_addr_count.by_addr_type.iter())

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

@@ -0,0 +1,78 @@
+//! Reused address count tracking — running counters of how many addresses
+//! are currently in (or have ever been in) the reused set, per address type
+//! plus an aggregated `all`. See the parent [`super`] module for the
+//! definition of "reused".
+//!
+//! Two counters are exposed:
+//! - `funded`: addresses currently funded AND with `funded_txo_count > 1`
+//! - `total`: addresses that have ever satisfied `funded_txo_count > 1` (monotonic)
+
+mod state;
+mod vecs;
+
+pub use state::AddrTypeToReusedAddrCount;
+pub use vecs::ReusedAddrCountAllVecs;
+
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Indexes, Version};
+use rayon::prelude::*;
+use vecdb::{AnyStoredVec, Database, Exit, Rw, StorageMode};
+
+use crate::indexes;
+
+/// Reused address counts: funded (currently with balance) and total (ever reused).
+#[derive(Traversable)]
+pub struct ReusedAddrCountsVecs<M: StorageMode = Rw> {
+    pub funded: ReusedAddrCountAllVecs<M>,
+    pub total: ReusedAddrCountAllVecs<M>,
+}
+
+impl ReusedAddrCountsVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self {
+            funded: ReusedAddrCountAllVecs::forced_import(
+                db,
+                "reused_addr_count",
+                version,
+                indexes,
+            )?,
+            total: ReusedAddrCountAllVecs::forced_import(
+                db,
+                "total_reused_addr_count",
+                version,
+                indexes,
+            )?,
+        })
+    }
+
+    pub(crate) fn min_stateful_len(&self) -> usize {
+        self.funded
+            .min_stateful_len()
+            .min(self.total.min_stateful_len())
+    }
+
+    pub(crate) fn par_iter_height_mut(
+        &mut self,
+    ) -> impl ParallelIterator<Item = &mut dyn AnyStoredVec> {
+        self.funded
+            .par_iter_height_mut()
+            .chain(self.total.par_iter_height_mut())
+    }
+
+    pub(crate) fn reset_height(&mut self) -> Result<()> {
+        self.funded.reset_height()?;
+        self.total.reset_height()?;
+        Ok(())
+    }
+
+    pub(crate) fn compute_rest(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()> {
+        self.funded.compute_rest(starting_indexes, exit)?;
+        self.total.compute_rest(starting_indexes, exit)?;
+        Ok(())
+    }
+}

crates/brk_computer/src/distribution/addr/reused/count/state.rs

@@ -0,0 +1,42 @@
+use brk_cohort::ByAddrType;
+use brk_types::{Height, StoredU64};
+use derive_more::{Deref, DerefMut};
+use vecdb::ReadableVec;
+
+use crate::internal::PerBlock;
+
+use super::vecs::ReusedAddrCountAllVecs;
+
+/// Runtime counter for reused address counts per address type.
+#[derive(Debug, Default, Deref, DerefMut)]
+pub struct AddrTypeToReusedAddrCount(ByAddrType<u64>);
+
+impl AddrTypeToReusedAddrCount {
+    #[inline]
+    pub(crate) fn sum(&self) -> u64 {
+        self.0.values().sum()
+    }
+}
+
+impl From<(&ReusedAddrCountAllVecs, Height)> for AddrTypeToReusedAddrCount {
+    #[inline]
+    fn from((vecs, starting_height): (&ReusedAddrCountAllVecs, Height)) -> Self {
+        if let Some(prev_height) = starting_height.decremented() {
+            let read = |v: &PerBlock<StoredU64>| -> u64 {
+                v.height.collect_one(prev_height).unwrap().into()
+            };
+            Self(ByAddrType {
+                p2pk65: read(&vecs.by_addr_type.p2pk65),
+                p2pk33: read(&vecs.by_addr_type.p2pk33),
+                p2pkh: read(&vecs.by_addr_type.p2pkh),
+                p2sh: read(&vecs.by_addr_type.p2sh),
+                p2wpkh: read(&vecs.by_addr_type.p2wpkh),
+                p2wsh: read(&vecs.by_addr_type.p2wsh),
+                p2tr: read(&vecs.by_addr_type.p2tr),
+                p2a: read(&vecs.by_addr_type.p2a),
+            })
+        } else {
+            Default::default()
+        }
+    }
+}

crates/brk_computer/src/distribution/addr/reused/count/vecs.rs

@@ -0,0 +1,30 @@
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{StoredU64, Version};
+use derive_more::{Deref, DerefMut};
+use vecdb::{Database, Rw, StorageMode};
+
+use crate::{
+    distribution::addr::WithAddrTypes,
+    indexes,
+    internal::PerBlock,
+};
+
+/// Reused address count (`all` + per-type) for a single variant (funded or total).
+#[derive(Deref, DerefMut, Traversable)]
+pub struct ReusedAddrCountAllVecs<M: StorageMode = Rw>(
+    #[traversable(flatten)] pub WithAddrTypes<PerBlock<StoredU64, M>>,
+);
+
+impl ReusedAddrCountAllVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        Ok(Self(WithAddrTypes::<PerBlock<StoredU64>>::forced_import(
+            db, name, version, indexes,
+        )?))
+    }
+}

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

@@ -0,0 +1,85 @@
+//! Reused address tracking.
+//!
+//! An address is "reused" if its lifetime `funded_txo_count > 1` — i.e. it
+//! has received more than one output across its lifetime. This is the
+//! simplest output-multiplicity proxy for address linkability.
+//!
+//! Two facets are tracked here:
+//! - [`count`] — how many distinct addresses are currently reused (funded)
+//!   and how many have *ever* been reused (total). Per address type plus
+//!   an aggregated `all`.
+//! - [`uses`] — per-block count of outputs going to addresses that were
+//!   already reused, plus the derived percent over total address-output
+//!   count (denominator from `scripts::count`).
+
+mod count;
+mod uses;
+
+pub use count::{AddrTypeToReusedAddrCount, ReusedAddrCountsVecs};
+pub use uses::{AddrTypeToReusedAddrUseCount, ReusedAddrUsesVecs};
+
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Indexes, Version};
+use rayon::prelude::*;
+use vecdb::{AnyStoredVec, Database, Exit, Rw, StorageMode};
+
+use crate::{
+    indexes,
+    internal::{WindowStartVec, Windows},
+    scripts,
+};
+
+/// Top-level container for all reused address tracking: counts (funded +
+/// total) plus per-block uses (count + percent).
+#[derive(Traversable)]
+pub struct ReusedAddrVecs<M: StorageMode = Rw> {
+    pub count: ReusedAddrCountsVecs<M>,
+    pub uses: ReusedAddrUsesVecs<M>,
+}
+
+impl ReusedAddrVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+        cached_starts: &Windows<&WindowStartVec>,
+    ) -> Result<Self> {
+        Ok(Self {
+            count: ReusedAddrCountsVecs::forced_import(db, version, indexes)?,
+            uses: ReusedAddrUsesVecs::forced_import(db, version, indexes, cached_starts)?,
+        })
+    }
+
+    pub(crate) fn min_stateful_len(&self) -> usize {
+        self.count
+            .min_stateful_len()
+            .min(self.uses.min_stateful_len())
+    }
+
+    pub(crate) fn par_iter_height_mut(
+        &mut self,
+    ) -> impl ParallelIterator<Item = &mut dyn AnyStoredVec> {
+        self.count
+            .par_iter_height_mut()
+            .chain(self.uses.par_iter_height_mut())
+    }
+
+    pub(crate) fn reset_height(&mut self) -> Result<()> {
+        self.count.reset_height()?;
+        self.uses.reset_height()?;
+        Ok(())
+    }
+
+    pub(crate) fn compute_rest(
+        &mut self,
+        starting_indexes: &Indexes,
+        scripts_count: &scripts::CountVecs,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.count.compute_rest(starting_indexes, exit)?;
+        self.uses
+            .compute_rest(starting_indexes, scripts_count, exit)?;
+        Ok(())
+    }
+}

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

@@ -0,0 +1,8 @@
+//! Per-block reused-address-use tracking. See [`vecs::ReusedAddrUsesVecs`]
+//! for the full description of the metric.
+
+mod state;
+mod vecs;
+
+pub use state::AddrTypeToReusedAddrUseCount;
+pub use vecs::ReusedAddrUsesVecs;

crates/brk_computer/src/distribution/addr/reused/uses/state.rs

@@ -0,0 +1,22 @@
+use brk_cohort::ByAddrType;
+use derive_more::{Deref, DerefMut};
+
+/// Per-block running counter of reused address uses, per address type.
+/// Reset at the start of each block (no disk recovery needed since the
+/// per-block flow is reconstructed from `process_received` deterministically).
+#[derive(Debug, Default, Deref, DerefMut)]
+pub struct AddrTypeToReusedAddrUseCount(ByAddrType<u64>);
+
+impl AddrTypeToReusedAddrUseCount {
+    #[inline]
+    pub(crate) fn sum(&self) -> u64 {
+        self.0.values().sum()
+    }
+
+    #[inline]
+    pub(crate) fn reset(&mut self) {
+        for v in self.0.values_mut() {
+            *v = 0;
+        }
+    }
+}

crates/brk_computer/src/distribution/addr/reused/uses/vecs.rs

@@ -0,0 +1,152 @@
+use brk_cohort::ByAddrType;
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{BasisPoints16, Height, Indexes, OutputType, StoredU64, Version};
+use rayon::prelude::*;
+use vecdb::{AnyStoredVec, Database, Exit, Rw, StorageMode};
+
+use crate::{
+    distribution::addr::WithAddrTypes,
+    indexes,
+    internal::{
+        PerBlockCumulativeRolling, PercentCumulativeRolling, RatioU64Bp16, WindowStartVec, Windows,
+    },
+    scripts,
+};
+
+use super::state::AddrTypeToReusedAddrUseCount;
+
+/// Per-block reused-address-use metrics. A "use" is a single output going
+/// to an address (not deduplicated): an address receiving N outputs in one
+/// block contributes N. The count only includes uses going to addresses
+/// that were *already* reused at the moment of the use, so the use that
+/// makes an address reused is not itself counted.
+///
+/// The denominator for the percent (total address-output count) lives in
+/// `scripts::count` and is reused here rather than duplicated.
+#[derive(Traversable)]
+pub struct ReusedAddrUsesVecs<M: StorageMode = Rw> {
+    pub reused_addr_use_count:
+        WithAddrTypes<PerBlockCumulativeRolling<StoredU64, StoredU64, M>>,
+    pub reused_addr_use_percent: WithAddrTypes<PercentCumulativeRolling<BasisPoints16, M>>,
+}
+
+impl ReusedAddrUsesVecs {
+    pub(crate) fn forced_import(
+        db: &Database,
+        version: Version,
+        indexes: &indexes::Vecs,
+        cached_starts: &Windows<&WindowStartVec>,
+    ) -> Result<Self> {
+        let reused_addr_use_count =
+            WithAddrTypes::<PerBlockCumulativeRolling<StoredU64, StoredU64>>::forced_import(
+                db,
+                "reused_addr_use_count",
+                version,
+                indexes,
+                cached_starts,
+            )?;
+        let percent_name = "reused_addr_use_percent";
+        let reused_addr_use_percent = WithAddrTypes {
+            all: PercentCumulativeRolling::forced_import(db, percent_name, version, indexes)?,
+            by_addr_type: ByAddrType::new_with_name(|type_name| {
+                PercentCumulativeRolling::forced_import(
+                    db,
+                    &format!("{type_name}_{percent_name}"),
+                    version,
+                    indexes,
+                )
+            })?,
+        };
+        Ok(Self {
+            reused_addr_use_count,
+            reused_addr_use_percent,
+        })
+    }
+
+    pub(crate) fn min_stateful_len(&self) -> usize {
+        self.reused_addr_use_count.min_stateful_len()
+    }
+
+    pub(crate) fn par_iter_height_mut(
+        &mut self,
+    ) -> impl ParallelIterator<Item = &mut dyn AnyStoredVec> {
+        self.reused_addr_use_count.par_iter_height_mut()
+    }
+
+    pub(crate) fn reset_height(&mut self) -> Result<()> {
+        self.reused_addr_use_count.reset_height()
+    }
+
+    #[inline(always)]
+    pub(crate) fn push_height(&mut self, reused: &AddrTypeToReusedAddrUseCount) {
+        self.reused_addr_use_count
+            .push_height(reused.sum(), reused.values().copied());
+    }
+
+    pub(crate) fn compute_rest(
+        &mut self,
+        starting_indexes: &Indexes,
+        scripts_count: &scripts::CountVecs,
+        exit: &Exit,
+    ) -> Result<()> {
+        self.reused_addr_use_count
+            .compute_rest(starting_indexes.height, exit)?;
+
+        compute_one_percent(
+            &mut self.reused_addr_use_percent.all,
+            &self.reused_addr_use_count.all,
+            &scripts_count.addr_output_count,
+            starting_indexes.height,
+            exit,
+        )?;
+        for otype in OutputType::ADDR_TYPES {
+            compute_one_percent(
+                self.reused_addr_use_percent
+                    .by_addr_type
+                    .get_mut_unwrap(otype),
+                self.reused_addr_use_count.by_addr_type.get_unwrap(otype),
+                denom_for_type(scripts_count, otype),
+                starting_indexes.height,
+                exit,
+            )?;
+        }
+        Ok(())
+    }
+}
+
+#[inline]
+fn compute_one_percent(
+    percent: &mut PercentCumulativeRolling<BasisPoints16>,
+    reused: &PerBlockCumulativeRolling<StoredU64, StoredU64>,
+    denom: &PerBlockCumulativeRolling<StoredU64, StoredU64>,
+    starting_height: Height,
+    exit: &Exit,
+) -> Result<()> {
+    percent.compute_binary::<StoredU64, StoredU64, RatioU64Bp16, _, _, _, _>(
+        starting_height,
+        &reused.cumulative.height,
+        &denom.cumulative.height,
+        reused.sum.as_array().map(|w| &w.height),
+        denom.sum.as_array().map(|w| &w.height),
+        exit,
+    )
+}
+
+#[inline]
+fn denom_for_type(
+    scripts_count: &scripts::CountVecs,
+    otype: OutputType,
+) -> &PerBlockCumulativeRolling<StoredU64, StoredU64> {
+    match otype {
+        OutputType::P2PK33 => &scripts_count.p2pk33,
+        OutputType::P2PK65 => &scripts_count.p2pk65,
+        OutputType::P2PKH => &scripts_count.p2pkh,
+        OutputType::P2SH => &scripts_count.p2sh,
+        OutputType::P2WPKH => &scripts_count.p2wpkh,
+        OutputType::P2WSH => &scripts_count.p2wsh,
+        OutputType::P2TR => &scripts_count.p2tr,
+        OutputType::P2A => &scripts_count.p2a,
+        _ => unreachable!("OutputType::ADDR_TYPES contains only address types"),
+    }
+}

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

@@ -1,20 +1,18 @@
-use brk_cohort::ByAddrType;
 use brk_error::Result;
 use brk_traversable::Traversable;
 use brk_types::{Height, StoredU64, Version};
+use derive_more::{Deref, DerefMut};
 use vecdb::{Database, Exit, Rw, StorageMode};
 
 use crate::{indexes, internal::PerBlock};
 
-use super::AddrCountsVecs;
+use super::{AddrCountsVecs, WithAddrTypes};
 
-/// Total address count (global + per-type) with all derived indexes
-#[derive(Traversable)]
-pub struct TotalAddrCountVecs<M: StorageMode = Rw> {
-    pub all: PerBlock<StoredU64, M>,
-    #[traversable(flatten)]
-    pub by_addr_type: ByAddrType<PerBlock<StoredU64, M>>,
-}
+/// Total address count (global + per-type) with all derived indexes.
+#[derive(Deref, DerefMut, Traversable)]
+pub struct TotalAddrCountVecs<M: StorageMode = Rw>(
+    #[traversable(flatten)] pub WithAddrTypes<PerBlock<StoredU64, M>>,
+);
 
 impl TotalAddrCountVecs {
     pub(crate) fn forced_import(
@@ -22,13 +20,12 @@ impl TotalAddrCountVecs {
         version: Version,
         indexes: &indexes::Vecs,
     ) -> Result<Self> {
-        let all = PerBlock::forced_import(db, "total_addr_count", version, indexes)?;
-
-        let by_addr_type: ByAddrType<PerBlock<StoredU64>> = ByAddrType::new_with_name(|name| {
-            PerBlock::forced_import(db, &format!("{name}_total_addr_count"), version, indexes)
-        })?;
-
-        Ok(Self { all, by_addr_type })
+        Ok(Self(WithAddrTypes::<PerBlock<StoredU64>>::forced_import(
+            db,
+            "total_addr_count",
+            version,
+            indexes,
+        )?))
     }
 
     /// Eagerly compute total = addr_count + empty_addr_count.
@@ -39,14 +36,14 @@ impl TotalAddrCountVecs {
         empty_addr_count: &AddrCountsVecs,
         exit: &Exit,
     ) -> Result<()> {
-        self.all.height.compute_add(
+        self.0.all.height.compute_add(
             max_from,
             &addr_count.all.height,
             &empty_addr_count.all.height,
             exit,
         )?;
 
-        for ((_, total), ((_, addr), (_, empty))) in self.by_addr_type.iter_mut().zip(
+        for ((_, total), ((_, addr), (_, empty))) in self.0.by_addr_type.iter_mut().zip(
             addr_count
                 .by_addr_type
                 .iter()

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

@@ -0,0 +1,173 @@
+//! Generic `all` + per-`AddrType` container, mirrors the `WithSth` pattern
+//! along the address-type axis. Used by every metric that tracks one
+//! aggregate value alongside a per-address-type breakdown.
+
+use brk_cohort::ByAddrType;
+use brk_error::Result;
+use brk_traversable::Traversable;
+use brk_types::{Height, Indexes, Version};
+use rayon::prelude::*;
+use schemars::JsonSchema;
+use vecdb::{AnyStoredVec, AnyVec, Database, EagerVec, Exit, PcoVec, WritableVec};
+
+use crate::{
+    indexes,
+    internal::{NumericValue, PerBlock, PerBlockCumulativeRolling, WindowStartVec, Windows},
+};
+
+/// `all` aggregate plus per-`AddrType` breakdown.
+#[derive(Clone, Traversable)]
+pub struct WithAddrTypes<T> {
+    pub all: T,
+    #[traversable(flatten)]
+    pub by_addr_type: ByAddrType<T>,
+}
+
+impl<T> WithAddrTypes<PerBlock<T>>
+where
+    T: NumericValue + JsonSchema,
+{
+    pub(crate) fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        indexes: &indexes::Vecs,
+    ) -> Result<Self> {
+        let all = PerBlock::forced_import(db, name, version, indexes)?;
+        let by_addr_type = ByAddrType::new_with_name(|type_name| {
+            PerBlock::forced_import(db, &format!("{type_name}_{name}"), version, indexes)
+        })?;
+        Ok(Self { all, by_addr_type })
+    }
+
+    pub(crate) fn min_stateful_len(&self) -> usize {
+        self.by_addr_type
+            .values()
+            .map(|v| v.height.len())
+            .min()
+            .unwrap()
+            .min(self.all.height.len())
+    }
+
+    pub(crate) fn par_iter_height_mut(
+        &mut self,
+    ) -> impl ParallelIterator<Item = &mut dyn AnyStoredVec> {
+        rayon::iter::once(&mut self.all.height as &mut dyn AnyStoredVec).chain(
+            self.by_addr_type
+                .par_values_mut()
+                .map(|v| &mut v.height as &mut dyn AnyStoredVec),
+        )
+    }
+
+    pub(crate) fn reset_height(&mut self) -> Result<()> {
+        self.all.height.reset()?;
+        for v in self.by_addr_type.values_mut() {
+            v.height.reset()?;
+        }
+        Ok(())
+    }
+
+    #[inline(always)]
+    pub(crate) fn push_height<U>(&mut self, total: U, per_type: impl IntoIterator<Item = U>)
+    where
+        U: Into<T>,
+    {
+        self.all.height.push(total.into());
+        for (v, value) in self.by_addr_type.values_mut().zip(per_type) {
+            v.height.push(value.into());
+        }
+    }
+
+    /// Compute `all.height` as the per-block sum of the per-type vecs.
+    pub(crate) fn compute_rest(
+        &mut self,
+        starting_indexes: &Indexes,
+        exit: &Exit,
+    ) -> Result<()> {
+        let sources: Vec<&EagerVec<PcoVec<Height, T>>> =
+            self.by_addr_type.values().map(|v| &v.height).collect();
+        self.all
+            .height
+            .compute_sum_of_others(starting_indexes.height, &sources, exit)?;
+        Ok(())
+    }
+}
+
+impl<T, C> WithAddrTypes<PerBlockCumulativeRolling<T, C>>
+where
+    T: NumericValue + JsonSchema + Into<C>,
+    C: NumericValue + JsonSchema,
+{
+    pub(crate) fn forced_import(
+        db: &Database,
+        name: &str,
+        version: Version,
+        indexes: &indexes::Vecs,
+        cached_starts: &Windows<&WindowStartVec>,
+    ) -> Result<Self> {
+        let all = PerBlockCumulativeRolling::forced_import(
+            db,
+            name,
+            version,
+            indexes,
+            cached_starts,
+        )?;
+        let by_addr_type = ByAddrType::new_with_name(|type_name| {
+            PerBlockCumulativeRolling::forced_import(
+                db,
+                &format!("{type_name}_{name}"),
+                version,
+                indexes,
+                cached_starts,
+            )
+        })?;
+        Ok(Self { all, by_addr_type })
+    }
+
+    pub(crate) fn min_stateful_len(&self) -> usize {
+        self.by_addr_type
+            .values()
+            .map(|v| v.block.len())
+            .min()
+            .unwrap()
+            .min(self.all.block.len())
+    }
+
+    pub(crate) fn par_iter_height_mut(
+        &mut self,
+    ) -> impl ParallelIterator<Item = &mut dyn AnyStoredVec> {
+        rayon::iter::once(&mut self.all.block as &mut dyn AnyStoredVec).chain(
+            self.by_addr_type
+                .par_values_mut()
+                .map(|v| &mut v.block as &mut dyn AnyStoredVec),
+        )
+    }
+
+    pub(crate) fn reset_height(&mut self) -> Result<()> {
+        self.all.block.reset()?;
+        for v in self.by_addr_type.values_mut() {
+            v.block.reset()?;
+        }
+        Ok(())
+    }
+
+    #[inline(always)]
+    pub(crate) fn push_height<U>(&mut self, total: U, per_type: impl IntoIterator<Item = U>)
+    where
+        U: Into<T>,
+    {
+        self.all.block.push(total.into());
+        for (v, value) in self.by_addr_type.values_mut().zip(per_type) {
+            v.block.push(value.into());
+        }
+    }
+
+    /// Finalize `cumulative` / `sum` / `average` for `all` and every per-type vec.
+    pub(crate) fn compute_rest(&mut self, max_from: Height, exit: &Exit) -> Result<()> {
+        self.all.compute_rest(max_from, exit)?;
+        for v in self.by_addr_type.values_mut() {
+            v.compute_rest(max_from, exit)?;
+        }
+        Ok(())
+    }
+}

crates/brk_computer/src/distribution/block/cohort/received.rs

@@ -3,7 +3,10 @@ use brk_types::{Cents, Sats, TypeIndex};
 use rustc_hash::FxHashMap;
 
 use crate::distribution::{
-    addr::{AddrTypeToActivityCounts, AddrTypeToVec},
+    addr::{
+        AddrTypeToActivityCounts, AddrTypeToExposedAddrCount, AddrTypeToExposedAddrSupply,
+        AddrTypeToReusedAddrCount, AddrTypeToReusedAddrUseCount, AddrTypeToVec,
+    },
     cohorts::AddrCohorts,
 };
 
@@ -25,6 +28,12 @@ pub(crate) fn process_received(
     addr_count: &mut ByAddrType<u64>,
     empty_addr_count: &mut ByAddrType<u64>,
     activity_counts: &mut AddrTypeToActivityCounts,
+    reused_addr_count: &mut AddrTypeToReusedAddrCount,
+    total_reused_addr_count: &mut AddrTypeToReusedAddrCount,
+    reused_addr_use_count: &mut AddrTypeToReusedAddrUseCount,
+    exposed_addr_count: &mut AddrTypeToExposedAddrCount,
+    total_exposed_addr_count: &mut AddrTypeToExposedAddrCount,
+    exposed_addr_supply: &mut AddrTypeToExposedAddrSupply,
 ) {
     let max_type_len = received_data
         .iter()
@@ -43,6 +52,12 @@ pub(crate) fn process_received(
         let type_addr_count = addr_count.get_mut(output_type).unwrap();
         let type_empty_count = empty_addr_count.get_mut(output_type).unwrap();
         let type_activity = activity_counts.get_mut_unwrap(output_type);
+        let type_reused_count = reused_addr_count.get_mut(output_type).unwrap();
+        let type_total_reused_count = total_reused_addr_count.get_mut(output_type).unwrap();
+        let type_reused_use_count = reused_addr_use_count.get_mut(output_type).unwrap();
+        let type_exposed_count = exposed_addr_count.get_mut(output_type).unwrap();
+        let type_total_exposed_count = total_exposed_addr_count.get_mut(output_type).unwrap();
+        let type_exposed_supply = exposed_addr_supply.get_mut(output_type).unwrap();
 
         // Aggregate receives by address - each address processed exactly once
         for (type_index, value) in vec {
@@ -57,6 +72,13 @@ pub(crate) fn process_received(
             // Track receiving activity - each address in receive aggregation
             type_activity.receiving += 1;
 
+            // Capture state BEFORE the receive mutates funded_txo_count
+            let was_funded = addr_data.is_funded();
+            let was_reused = addr_data.is_reused();
+            let funded_txo_count_before = addr_data.funded_txo_count;
+            let was_pubkey_exposed = addr_data.is_pubkey_exposed(output_type);
+            let exposed_contribution_before = addr_data.exposed_supply_contribution(output_type);
+
             match status {
                 TrackingStatus::New => {
                     *type_addr_count += 1;
@@ -134,6 +156,54 @@ pub(crate) fn process_received(
                         .receive_outputs(addr_data, recv.total_value, price, recv.output_count);
                 }
             }
+
+            // Update reused counts based on the post-receive state
+            let is_now_reused = addr_data.is_reused();
+            if is_now_reused && !was_reused {
+                // Newly crossed the reuse threshold this block
+                *type_reused_count += 1;
+                *type_total_reused_count += 1;
+            } else if is_now_reused && !was_funded {
+                // Already-reused address reactivating into the funded set
+                *type_reused_count += 1;
+            }
+
+            // Per-block reused-use count: every individual output to this
+            // address counts iff the address was already reused at the
+            // moment of that output. With aggregation, that means we
+            // skip enough outputs at the front to take the lifetime
+            // funding count from `funded_txo_count_before` past 1, then
+            // count the rest. `skipped` is `max(0, 2 - before)`.
+            let skipped = 2u32.saturating_sub(funded_txo_count_before);
+            let counted = recv.output_count.saturating_sub(skipped);
+            *type_reused_use_count += u64::from(counted);
+
+            // Update exposed counts. The address's pubkey-exposure state
+            // is unchanged by a receive (spent_txo_count unchanged), so we
+            // can use the captured `was_pubkey_exposed` for both pre and post.
+            // After the receive the address is always funded, so it's in the
+            // funded exposed set iff its pubkey is exposed.
+            //
+            // Funded exposed enters when the address wasn't funded before but
+            // is now AND its pubkey is exposed.
+            // Total exposed (pk_exposed_at_funding types only) increments on
+            // first-ever receive (status == TrackingStatus::New); for other
+            // types it's incremented in process_sent on the first spend.
+            if !was_funded && was_pubkey_exposed {
+                *type_exposed_count += 1;
+            }
+            if output_type.pubkey_exposed_at_funding()
+                && matches!(status, TrackingStatus::New)
+            {
+                *type_total_exposed_count += 1;
+            }
+
+            // Update exposed supply via post-receive contribution delta.
+            let exposed_contribution_after =
+                addr_data.exposed_supply_contribution(output_type);
+            // Receives can only add to balance and membership, so the delta
+            // is always non-negative.
+            *type_exposed_supply += exposed_contribution_after - exposed_contribution_before;
         }
     }
 }

crates/brk_computer/src/distribution/block/cohort/sent.rs

@@ -5,7 +5,10 @@ use rustc_hash::FxHashSet;
 use vecdb::VecIndex;
 
 use crate::distribution::{
-    addr::{AddrTypeToActivityCounts, HeightToAddrTypeToVec},
+    addr::{
+        AddrTypeToActivityCounts, AddrTypeToExposedAddrCount, AddrTypeToExposedAddrSupply,
+        AddrTypeToReusedAddrCount, HeightToAddrTypeToVec,
+    },
     cohorts::AddrCohorts,
     compute::PriceRangeMax,
 };
@@ -35,6 +38,10 @@ pub(crate) fn process_sent(
     addr_count: &mut ByAddrType<u64>,
     empty_addr_count: &mut ByAddrType<u64>,
     activity_counts: &mut AddrTypeToActivityCounts,
+    reused_addr_count: &mut AddrTypeToReusedAddrCount,
+    exposed_addr_count: &mut AddrTypeToExposedAddrCount,
+    total_exposed_addr_count: &mut AddrTypeToExposedAddrCount,
+    exposed_addr_supply: &mut AddrTypeToExposedAddrSupply,
     received_addrs: &ByAddrType<FxHashSet<TypeIndex>>,
     height_to_price: &[Cents],
     height_to_timestamp: &[Timestamp],
@@ -57,6 +64,10 @@ pub(crate) fn process_sent(
             let type_addr_count = addr_count.get_mut(output_type).unwrap();
             let type_empty_count = empty_addr_count.get_mut(output_type).unwrap();
             let type_activity = activity_counts.get_mut_unwrap(output_type);
+            let type_reused_count = reused_addr_count.get_mut(output_type).unwrap();
+            let type_exposed_count = exposed_addr_count.get_mut(output_type).unwrap();
+            let type_total_exposed_count = total_exposed_addr_count.get_mut(output_type).unwrap();
+            let type_exposed_supply = exposed_addr_supply.get_mut(output_type).unwrap();
             let type_received = received_addrs.get(output_type);
             let type_seen = seen_senders.get_mut_unwrap(output_type);
 
@@ -78,6 +89,11 @@ pub(crate) fn process_sent(
 
                 let will_be_empty = addr_data.has_1_utxos();
 
+                // Capture exposed state BEFORE the spend mutates spent_txo_count.
+                let was_pubkey_exposed = addr_data.is_pubkey_exposed(output_type);
+                let exposed_contribution_before =
+                    addr_data.exposed_supply_contribution(output_type);
+
                 // Compute buckets once
                 let prev_bucket = AmountBucket::from(prev_balance);
                 let new_bucket = AmountBucket::from(new_balance);
@@ -91,6 +107,27 @@ pub(crate) fn process_sent(
                     .unwrap();
 
                 cohort_state.send(addr_data, value, current_price, prev_price, peak_price, age)?;
+                // addr_data.spent_txo_count is now incremented by 1.
+
+                // Update exposed supply via post-spend contribution delta.
+                let exposed_contribution_after =
+                    addr_data.exposed_supply_contribution(output_type);
+                if exposed_contribution_after >= exposed_contribution_before {
+                    *type_exposed_supply += exposed_contribution_after - exposed_contribution_before;
+                } else {
+                    *type_exposed_supply -= exposed_contribution_before - exposed_contribution_after;
+                }
+
+                // Update exposed counts on first-ever pubkey exposure.
+                // For non-pk-exposed types this fires on the first spend; for
+                // pk-exposed types it never fires here (was_pubkey_exposed was
+                // already true at first receive in process_received).
+                if !was_pubkey_exposed {
+                    *type_total_exposed_count += 1;
+                    if !will_be_empty {
+                        *type_exposed_count += 1;
+                    }
+                }
 
                 // If crossing a bucket boundary, remove the (now-updated) address from old bucket
                 if will_be_empty || crossing_boundary {
@@ -101,6 +138,17 @@ pub(crate) fn process_sent(
                 if will_be_empty {
                     *type_addr_count -= 1;
                     *type_empty_count += 1;
+                    // Reused addr leaving the funded reused set
+                    if addr_data.is_reused() {
+                        *type_reused_count -= 1;
+                    }
+                    // Exposed addr leaving the funded exposed set: was in set
+                    // iff its pubkey was exposed pre-spend (since it was funded
+                    // to be in process_sent in the first place), and now leaves
+                    // because it's empty.
+                    if was_pubkey_exposed {
+                        *type_exposed_count -= 1;
+                    }
                     lookup.move_to_empty(output_type, type_index);
                 } else if crossing_boundary {
                     cohorts

crates/brk_computer/src/distribution/compute/block_loop.rs

@@ -11,7 +11,10 @@ use vecdb::{AnyStoredVec, AnyVec, Exit, ReadableVec, VecIndex, WritableVec, unli
 
 use crate::{
     distribution::{
-        addr::{AddrTypeToActivityCounts, AddrTypeToAddrCount},
+        addr::{
+            AddrTypeToActivityCounts, AddrTypeToAddrCount, AddrTypeToExposedAddrCount,
+            AddrTypeToExposedAddrSupply, AddrTypeToReusedAddrCount, AddrTypeToReusedAddrUseCount,
+        },
         block::{
             AddrCache, InputsResult, process_inputs, process_outputs, process_received,
             process_sent,
@@ -192,22 +195,41 @@ pub(crate) fn process_blocks(
 
     // Track running totals - recover from previous height if resuming
     debug!("recovering addr_counts from height {}", starting_height);
-    let (mut addr_counts, mut empty_addr_counts) = if starting_height > Height::ZERO {
-        let addr_counts =
-            AddrTypeToAddrCount::from((&vecs.addrs.funded.by_addr_type, starting_height));
-        let empty_addr_counts =
-            AddrTypeToAddrCount::from((&vecs.addrs.empty.by_addr_type, starting_height));
-        (addr_counts, empty_addr_counts)
+    let (
+        mut addr_counts,
+        mut empty_addr_counts,
+        mut reused_addr_counts,
+        mut total_reused_addr_counts,
+        mut exposed_addr_counts,
+        mut total_exposed_addr_counts,
+        mut exposed_addr_supply,
+    ) = if starting_height > Height::ZERO {
+        (
+            AddrTypeToAddrCount::from((&vecs.addrs.funded.by_addr_type, starting_height)),
+            AddrTypeToAddrCount::from((&vecs.addrs.empty.by_addr_type, starting_height)),
+            AddrTypeToReusedAddrCount::from((&vecs.addrs.reused.count.funded, starting_height)),
+            AddrTypeToReusedAddrCount::from((&vecs.addrs.reused.count.total, starting_height)),
+            AddrTypeToExposedAddrCount::from((&vecs.addrs.exposed.count.funded, starting_height)),
+            AddrTypeToExposedAddrCount::from((&vecs.addrs.exposed.count.total, starting_height)),
+            AddrTypeToExposedAddrSupply::from((&vecs.addrs.exposed.supply, starting_height)),
+        )
     } else {
         (
             AddrTypeToAddrCount::default(),
             AddrTypeToAddrCount::default(),
+            AddrTypeToReusedAddrCount::default(),
+            AddrTypeToReusedAddrCount::default(),
+            AddrTypeToExposedAddrCount::default(),
+            AddrTypeToExposedAddrCount::default(),
+            AddrTypeToExposedAddrSupply::default(),
         )
     };
     debug!("addr_counts recovered");
 
     // Track activity counts - reset each block
     let mut activity_counts = AddrTypeToActivityCounts::default();
+    // Reused-use count - per-block flow, reset each block
+    let mut reused_addr_use_counts = AddrTypeToReusedAddrUseCount::default();
 
     debug!("creating AddrCache");
     let mut cache = AddrCache::new();
@@ -226,6 +248,8 @@ pub(crate) fn process_blocks(
             .chain(vecs.addrs.funded.par_iter_height_mut())
             .chain(vecs.addrs.empty.par_iter_height_mut())
             .chain(vecs.addrs.activity.par_iter_height_mut())
+            .chain(vecs.addrs.reused.par_iter_height_mut())
+            .chain(vecs.addrs.exposed.par_iter_height_mut())
             .chain(rayon::iter::once(
                 &mut vecs.coinblocks_destroyed.block as &mut dyn AnyStoredVec,
             ))
@@ -278,6 +302,7 @@ pub(crate) fn process_blocks(
 
         // Reset per-block activity counts
         activity_counts.reset();
+        reused_addr_use_counts.reset();
 
         // Process outputs, inputs, and tick-tock in parallel via rayon::join.
         // Collection (build tx_index mappings + bulk mmap reads) is merged into the
@@ -447,6 +472,12 @@ pub(crate) fn process_blocks(
                     &mut addr_counts,
                     &mut empty_addr_counts,
                     &mut activity_counts,
+                    &mut reused_addr_counts,
+                    &mut total_reused_addr_counts,
+                    &mut reused_addr_use_counts,
+                    &mut exposed_addr_counts,
+                    &mut total_exposed_addr_counts,
+                    &mut exposed_addr_supply,
                 );
 
                 // Process sent inputs (addresses sending funds)
@@ -459,6 +490,10 @@ pub(crate) fn process_blocks(
                     &mut addr_counts,
                     &mut empty_addr_counts,
                     &mut activity_counts,
+                    &mut reused_addr_counts,
+                    &mut exposed_addr_counts,
+                    &mut total_exposed_addr_counts,
+                    &mut exposed_addr_supply,
                     &received_addrs,
                     height_to_price_vec,
                     height_to_timestamp_vec,
@@ -481,6 +516,27 @@ pub(crate) fn process_blocks(
             .empty
             .push_height(empty_addr_counts.sum(), &empty_addr_counts);
         vecs.addrs.activity.push_height(&activity_counts);
+        vecs.addrs.reused.count.funded.push_height(
+            reused_addr_counts.sum(),
+            reused_addr_counts.values().copied(),
+        );
+        vecs.addrs.reused.count.total.push_height(
+            total_reused_addr_counts.sum(),
+            total_reused_addr_counts.values().copied(),
+        );
+        vecs.addrs.reused.uses.push_height(&reused_addr_use_counts);
+        vecs.addrs.exposed.count.funded.push_height(
+            exposed_addr_counts.sum(),
+            exposed_addr_counts.values().copied(),
+        );
+        vecs.addrs.exposed.count.total.push_height(
+            total_exposed_addr_counts.sum(),
+            total_exposed_addr_counts.values().copied(),
+        );
+        vecs.addrs.exposed.supply.push_height(
+            exposed_addr_supply.sum(),
+            exposed_addr_supply.values().copied(),
+        );
 
         let is_last_of_day = is_last_of_day[offset];
         let date_opt = is_last_of_day.then(|| Date::from(timestamp));

crates/brk_computer/src/distribution/compute/write.rs

@@ -79,6 +79,8 @@ pub(crate) fn write(
         .chain(vecs.addrs.funded.par_iter_height_mut())
         .chain(vecs.addrs.empty.par_iter_height_mut())
         .chain(vecs.addrs.activity.par_iter_height_mut())
+        .chain(vecs.addrs.reused.par_iter_height_mut())
+        .chain(vecs.addrs.exposed.par_iter_height_mut())
         .chain(
             [
                 &mut vecs.supply_state as &mut dyn AnyStoredVec,

crates/brk_computer/src/distribution/vecs.rs

@@ -27,12 +27,15 @@ use crate::{
         PerBlockCumulativeRolling, WindowStartVec, Windows,
         db_utils::{finalize_db, open_db},
     },
-    outputs, prices, transactions,
+    outputs, prices, scripts, transactions,
 };
 
 use super::{
     AddrCohorts, AddrsDataVecs, AnyAddrIndexesVecs, RangeMap, UTXOCohorts,
-    addr::{AddrActivityVecs, AddrCountsVecs, DeltaVecs, NewAddrCountVecs, TotalAddrCountVecs},
+    addr::{
+        AddrActivityVecs, AddrCountsVecs, DeltaVecs, ExposedAddrVecs, NewAddrCountVecs,
+        ReusedAddrVecs, TotalAddrCountVecs,
+    },
 };
 
 const VERSION: Version = Version::new(22);
@@ -44,6 +47,8 @@ pub struct AddrMetricsVecs<M: StorageMode = Rw> {
     pub activity: AddrActivityVecs<M>,
     pub total: TotalAddrCountVecs<M>,
     pub new: NewAddrCountVecs<M>,
+    pub reused: ReusedAddrVecs<M>,
+    pub exposed: ExposedAddrVecs<M>,
     pub delta: DeltaVecs,
     #[traversable(wrap = "indexes", rename = "funded")]
     pub funded_index:
@@ -154,6 +159,13 @@ impl Vecs {
         // Per-block delta of total (global + per-type)
         let new_addr_count = NewAddrCountVecs::forced_import(&db, version, indexes, cached_starts)?;
 
+        // Reused address tracking (counts + per-block uses + percent)
+        let reused_addr_count =
+            ReusedAddrVecs::forced_import(&db, version, indexes, cached_starts)?;
+
+        // Exposed address tracking (counts + supply) - quantum / pubkey-exposure sense
+        let exposed_addr_vecs = ExposedAddrVecs::forced_import(&db, version, indexes)?;
+
         // Growth rate: delta change + rate (global + per-type)
         let delta = DeltaVecs::new(version, &addr_count, cached_starts, indexes);
 
@@ -169,6 +181,8 @@ impl Vecs {
                 activity: addr_activity,
                 total: total_addr_count,
                 new: new_addr_count,
+                reused: reused_addr_count,
+                exposed: exposed_addr_vecs,
                 delta,
                 funded_index: funded_addr_index,
                 empty_index: empty_addr_index,
@@ -221,6 +235,7 @@ impl Vecs {
         indexes: &indexes::Vecs,
         inputs: &inputs::Vecs,
         outputs: &outputs::Vecs,
+        scripts: &scripts::Vecs,
         transactions: &transactions::Vecs,
         blocks: &blocks::Vecs,
         prices: &prices::Vecs,
@@ -285,6 +300,8 @@ impl Vecs {
             self.addrs.funded.reset_height()?;
             self.addrs.empty.reset_height()?;
             self.addrs.activity.reset_height()?;
+            self.addrs.reused.reset_height()?;
+            self.addrs.exposed.reset_height()?;
             reset_state(
                 &mut self.any_addr_indexes,
                 &mut self.addrs_data,
@@ -454,6 +471,10 @@ impl Vecs {
         // 6b. Compute address count sum (by addr_type -> all)
         self.addrs.funded.compute_rest(starting_indexes, exit)?;
         self.addrs.empty.compute_rest(starting_indexes, exit)?;
+        self.addrs
+            .reused
+            .compute_rest(starting_indexes, &scripts.count, exit)?;
+        self.addrs.exposed.compute_rest(starting_indexes, exit)?;
 
         // 6c. Compute total_addr_count = addr_count + empty_addr_count
         self.addrs.total.compute(
@@ -524,6 +545,8 @@ impl Vecs {
             .min(Height::from(self.addrs.funded.min_stateful_len()))
             .min(Height::from(self.addrs.empty.min_stateful_len()))
             .min(Height::from(self.addrs.activity.min_stateful_len()))
+            .min(Height::from(self.addrs.reused.min_stateful_len()))
+            .min(Height::from(self.addrs.exposed.min_stateful_len()))
             .min(Height::from(self.coinblocks_destroyed.block.len()))
     }
 }