From 2ce6a7cee2123a706834141311f72e83b00df4d6 Mon Sep 17 00:00:00 2001 From: nym21 Date: Thu, 19 Mar 2026 19:28:59 +0100 Subject: [PATCH] global: snapshot --- .../src/distribution/metrics/activity/core.rs | 9 -- .../src/distribution/metrics/activity/full.rs | 8 +- .../src/distribution/metrics/cohort/all.rs | 7 +- .../src/distribution/metrics/cohort/core.rs | 2 - .../distribution/metrics/cohort/extended.rs | 7 +- .../metrics/cohort/extended_adjusted.rs | 2 +- .../src/distribution/metrics/mod.rs | 62 +++++++- .../distribution/metrics/unrealized/base.rs | 48 +----- .../distribution/metrics/unrealized/full.rs | 142 +++++++----------- .../distribution/metrics/unrealized/mod.rs | 31 ++-- .../state/cost_basis/unrealized.rs | 14 -- 11 files changed, 123 insertions(+), 209 deletions(-) diff --git a/crates/brk_computer/src/distribution/metrics/activity/core.rs b/crates/brk_computer/src/distribution/metrics/activity/core.rs index 846c71f9c..de56e4f2d 100644 --- a/crates/brk_computer/src/distribution/metrics/activity/core.rs +++ b/crates/brk_computer/src/distribution/metrics/activity/core.rs @@ -107,15 +107,6 @@ impl ActivityCore { .compute_rest_part1(prices, starting_indexes, exit)?; self.coindays_destroyed .compute_rest(starting_indexes.height, exit)?; - Ok(()) - } - - pub(crate) fn compute_sent_profitability( - &mut self, - prices: &prices::Vecs, - starting_indexes: &Indexes, - exit: &Exit, - ) -> Result<()> { self.transfer_volume_in_profit .compute_rest(starting_indexes.height, prices, exit)?; self.transfer_volume_in_loss diff --git a/crates/brk_computer/src/distribution/metrics/activity/full.rs b/crates/brk_computer/src/distribution/metrics/activity/full.rs index e9f417119..d06b114fb 100644 --- a/crates/brk_computer/src/distribution/metrics/activity/full.rs +++ b/crates/brk_computer/src/distribution/metrics/activity/full.rs @@ -89,14 +89,8 @@ impl ActivityFull { starting_indexes: &Indexes, exit: &Exit, ) -> Result<()> { - self.inner.compute_rest_part1(prices, starting_indexes, exit) - } + self.inner.compute_rest_part1(prices, starting_indexes, exit)?; - pub(crate) fn compute_rest_part2( - &mut self, - starting_indexes: &Indexes, - exit: &Exit, - ) -> Result<()> { for ((dormancy, cdd_sum), tv_sum) in self .dormancy .as_mut_array() diff --git a/crates/brk_computer/src/distribution/metrics/cohort/all.rs b/crates/brk_computer/src/distribution/metrics/cohort/all.rs index 03a2f6bdf..25e507ab3 100644 --- a/crates/brk_computer/src/distribution/metrics/cohort/all.rs +++ b/crates/brk_computer/src/distribution/metrics/cohort/all.rs @@ -11,7 +11,7 @@ use crate::{ blocks, distribution::metrics::{ ActivityFull, AdjustedSopr, CohortMetricsBase, CostBasis, ImportConfig, OutputsBase, - RealizedFull, RelativeForAll, SupplyCore, UnrealizedFull, + RealizedFull, RelativeForAll, SupplyCore, UnrealizedFull, UnrealizedLike, }, prices, }; @@ -144,11 +144,6 @@ impl AllCohortMetrics { exit, )?; - self.activity.compute_rest_part2( - starting_indexes, - exit, - )?; - Ok(()) } } diff --git a/crates/brk_computer/src/distribution/metrics/cohort/core.rs b/crates/brk_computer/src/distribution/metrics/cohort/core.rs index 8a2366784..52df05068 100644 --- a/crates/brk_computer/src/distribution/metrics/cohort/core.rs +++ b/crates/brk_computer/src/distribution/metrics/cohort/core.rs @@ -110,8 +110,6 @@ impl CoreCohortMetrics { self.activity .compute_rest_part1(prices, starting_indexes, exit)?; - self.activity - .compute_sent_profitability(prices, starting_indexes, exit)?; self.realized .compute_rest_part1(starting_indexes, exit)?; diff --git a/crates/brk_computer/src/distribution/metrics/cohort/extended.rs b/crates/brk_computer/src/distribution/metrics/cohort/extended.rs index 784e9a857..dae5391df 100644 --- a/crates/brk_computer/src/distribution/metrics/cohort/extended.rs +++ b/crates/brk_computer/src/distribution/metrics/cohort/extended.rs @@ -11,7 +11,7 @@ use crate::{ blocks, distribution::metrics::{ ActivityFull, CohortMetricsBase, CostBasis, ImportConfig, OutputsBase, RealizedFull, - RelativeWithExtended, SupplyCore, UnrealizedFull, + RelativeWithExtended, SupplyCore, UnrealizedFull, UnrealizedLike, }, prices, }; @@ -124,11 +124,6 @@ impl ExtendedCohortMetrics { exit, )?; - self.activity.compute_rest_part2( - starting_indexes, - exit, - )?; - Ok(()) } } diff --git a/crates/brk_computer/src/distribution/metrics/cohort/extended_adjusted.rs b/crates/brk_computer/src/distribution/metrics/cohort/extended_adjusted.rs index fdc753fac..cb639cc17 100644 --- a/crates/brk_computer/src/distribution/metrics/cohort/extended_adjusted.rs +++ b/crates/brk_computer/src/distribution/metrics/cohort/extended_adjusted.rs @@ -32,7 +32,7 @@ impl CohortMetricsBase for ExtendedAdjustedCohortMetrics { type RealizedVecs = RealizedFull; type UnrealizedVecs = UnrealizedFull; - impl_cohort_accessors!(); + impl_cohort_accessors_inner!(); fn validate_computed_versions(&mut self, base_version: Version) -> Result<()> { self.inner.validate_computed_versions(base_version) diff --git a/crates/brk_computer/src/distribution/metrics/mod.rs b/crates/brk_computer/src/distribution/metrics/mod.rs index 1f3c2cbe8..8b261fc82 100644 --- a/crates/brk_computer/src/distribution/metrics/mod.rs +++ b/crates/brk_computer/src/distribution/metrics/mod.rs @@ -51,6 +51,52 @@ macro_rules! impl_cohort_accessors { fn unrealized_mut(&mut self) -> &mut Self::UnrealizedVecs { &mut self.unrealized } + fn supply_and_unrealized_mut(&mut self) -> (&$crate::distribution::metrics::SupplyCore, &mut Self::UnrealizedVecs) { + (&*self.supply, &mut self.unrealized) + } + }; +} + +/// Variant of `impl_cohort_accessors` for wrapper types that deref to an `inner` field. +/// Uses `self.inner.*` directly to enable split borrows that Rust cannot infer through `Deref`. +macro_rules! impl_cohort_accessors_inner { + () => { + fn filter(&self) -> &brk_cohort::Filter { + &self.inner.filter + } + fn supply(&self) -> &$crate::distribution::metrics::SupplyCore { + &self.inner.supply + } + fn supply_mut(&mut self) -> &mut $crate::distribution::metrics::SupplyCore { + &mut self.inner.supply + } + fn outputs(&self) -> &$crate::distribution::metrics::OutputsBase { + &self.inner.outputs + } + fn outputs_mut(&mut self) -> &mut $crate::distribution::metrics::OutputsBase { + &mut self.inner.outputs + } + fn activity(&self) -> &Self::ActivityVecs { + &self.inner.activity + } + fn activity_mut(&mut self) -> &mut Self::ActivityVecs { + &mut self.inner.activity + } + fn realized(&self) -> &Self::RealizedVecs { + &self.inner.realized + } + fn realized_mut(&mut self) -> &mut Self::RealizedVecs { + &mut self.inner.realized + } + fn unrealized(&self) -> &Self::UnrealizedVecs { + &self.inner.unrealized + } + fn unrealized_mut(&mut self) -> &mut Self::UnrealizedVecs { + &mut self.inner.unrealized + } + fn supply_and_unrealized_mut(&mut self) -> (&$crate::distribution::metrics::SupplyCore, &mut Self::UnrealizedVecs) { + (&*self.inner.supply, &mut self.inner.unrealized) + } }; } @@ -148,6 +194,7 @@ pub trait CohortMetricsBase: fn realized_mut(&mut self) -> &mut Self::RealizedVecs; fn unrealized(&self) -> &Self::UnrealizedVecs; fn unrealized_mut(&mut self) -> &mut Self::UnrealizedVecs; + fn supply_and_unrealized_mut(&mut self) -> (&SupplyCore, &mut Self::UnrealizedVecs); /// Convenience: access activity as `&ActivityCore` (via `ActivityLike::as_core`). fn activity_core(&self) -> &ActivityCore { @@ -224,17 +271,18 @@ pub trait CohortMetricsBase: .compute(prices, starting_indexes.height, exit)?; self.activity_mut() .compute_rest_part1(prices, starting_indexes, exit)?; - self.activity_core_mut() - .compute_sent_profitability(prices, starting_indexes, exit)?; self.realized_mut() .compute_rest_part1(starting_indexes, exit)?; - self.unrealized_mut() - .compute_rest(prices, starting_indexes, exit)?; - - self.unrealized_mut() - .compute_net_sentiment_height(starting_indexes, exit)?; + let (supply, unrealized) = self.supply_and_unrealized_mut(); + unrealized.compute_rest( + prices, + starting_indexes, + &supply.in_profit.sats.height, + &supply.in_loss.sats.height, + exit, + )?; Ok(()) } diff --git a/crates/brk_computer/src/distribution/metrics/unrealized/base.rs b/crates/brk_computer/src/distribution/metrics/unrealized/base.rs index 137a02305..678b77adc 100644 --- a/crates/brk_computer/src/distribution/metrics/unrealized/base.rs +++ b/crates/brk_computer/src/distribution/metrics/unrealized/base.rs @@ -1,6 +1,6 @@ use brk_error::Result; use brk_traversable::Traversable; -use brk_types::{CentsSats, CentsSquaredSats, Height, Indexes, Version}; +use brk_types::{CentsSquaredSats, Height, Indexes, Version}; use derive_more::{Deref, DerefMut}; use vecdb::{AnyStoredVec, AnyVec, BytesVec, Exit, ReadableVec, Rw, StorageMode, WritableVec}; @@ -15,10 +15,6 @@ pub struct UnrealizedBase { #[traversable(flatten)] pub core: UnrealizedCore, - #[traversable(hidden)] - pub invested_capital_in_profit_raw: M::Stored>, - #[traversable(hidden)] - pub invested_capital_in_loss_raw: M::Stored>, #[traversable(hidden)] pub investor_cap_in_profit_raw: M::Stored>, #[traversable(hidden)] @@ -31,16 +27,11 @@ impl UnrealizedBase { let core = UnrealizedCore::forced_import(cfg)?; - let invested_capital_in_profit_raw = - cfg.import("invested_capital_in_profit_raw", v0)?; - let invested_capital_in_loss_raw = cfg.import("invested_capital_in_loss_raw", v0)?; let investor_cap_in_profit_raw = cfg.import("investor_cap_in_profit_raw", v0)?; let investor_cap_in_loss_raw = cfg.import("investor_cap_in_loss_raw", v0)?; Ok(Self { core, - invested_capital_in_profit_raw, - invested_capital_in_loss_raw, investor_cap_in_profit_raw, investor_cap_in_loss_raw, }) @@ -49,8 +40,6 @@ impl UnrealizedBase { pub(crate) fn min_stateful_len(&self) -> usize { self.core .min_stateful_len() - .min(self.invested_capital_in_profit_raw.len()) - .min(self.invested_capital_in_loss_raw.len()) .min(self.investor_cap_in_profit_raw.len()) .min(self.investor_cap_in_loss_raw.len()) } @@ -59,10 +48,6 @@ impl UnrealizedBase { pub(crate) fn push_state(&mut self, state: &UnrealizedState) { self.core.push_state(state); - self.invested_capital_in_profit_raw - .push(CentsSats::new(state.invested_capital_in_profit_raw)); - self.invested_capital_in_loss_raw - .push(CentsSats::new(state.invested_capital_in_loss_raw)); self.investor_cap_in_profit_raw .push(CentsSquaredSats::new(state.investor_cap_in_profit_raw)); self.investor_cap_in_loss_raw @@ -71,8 +56,6 @@ impl UnrealizedBase { pub(crate) fn collect_vecs_mut(&mut self) -> Vec<&mut dyn AnyStoredVec> { let mut vecs = self.core.collect_vecs_mut(); - vecs.push(&mut self.invested_capital_in_profit_raw as &mut dyn AnyStoredVec); - vecs.push(&mut self.invested_capital_in_loss_raw as &mut dyn AnyStoredVec); vecs.push(&mut self.investor_cap_in_profit_raw as &mut dyn AnyStoredVec); vecs.push(&mut self.investor_cap_in_loss_raw as &mut dyn AnyStoredVec); vecs @@ -90,28 +73,15 @@ impl UnrealizedBase { .compute_from_stateful(starting_indexes, &core_refs, exit)?; let start = self - .invested_capital_in_profit_raw + .investor_cap_in_profit_raw .len() - .min(self.invested_capital_in_loss_raw.len()) - .min(self.investor_cap_in_profit_raw.len()) .min(self.investor_cap_in_loss_raw.len()); let end = others .iter() - .map(|o| o.invested_capital_in_profit_raw.len()) + .map(|o| o.investor_cap_in_profit_raw.len()) .min() .unwrap_or(0); - let invested_profit_ranges: Vec> = others - .iter() - .map(|o| { - o.invested_capital_in_profit_raw - .collect_range_at(start, end) - }) - .collect(); - let invested_loss_ranges: Vec> = others - .iter() - .map(|o| o.invested_capital_in_loss_raw.collect_range_at(start, end)) - .collect(); let investor_profit_ranges: Vec> = others .iter() .map(|o| o.investor_cap_in_profit_raw.collect_range_at(start, end)) @@ -121,10 +91,6 @@ impl UnrealizedBase { .map(|o| o.investor_cap_in_loss_raw.collect_range_at(start, end)) .collect(); - self.invested_capital_in_profit_raw - .truncate_if_needed_at(start)?; - self.invested_capital_in_loss_raw - .truncate_if_needed_at(start)?; self.investor_cap_in_profit_raw .truncate_if_needed_at(start)?; self.investor_cap_in_loss_raw @@ -133,22 +99,14 @@ impl UnrealizedBase { for i in start..end { let local_i = i - start; - let mut sum_invested_profit = CentsSats::ZERO; - let mut sum_invested_loss = CentsSats::ZERO; let mut sum_investor_profit = CentsSquaredSats::ZERO; let mut sum_investor_loss = CentsSquaredSats::ZERO; for idx in 0..others.len() { - sum_invested_profit += invested_profit_ranges[idx][local_i]; - sum_invested_loss += invested_loss_ranges[idx][local_i]; sum_investor_profit += investor_profit_ranges[idx][local_i]; sum_investor_loss += investor_loss_ranges[idx][local_i]; } - self.invested_capital_in_profit_raw - .push(sum_invested_profit); - self.invested_capital_in_loss_raw - .push(sum_invested_loss); self.investor_cap_in_profit_raw .push(sum_investor_profit); self.investor_cap_in_loss_raw diff --git a/crates/brk_computer/src/distribution/metrics/unrealized/full.rs b/crates/brk_computer/src/distribution/metrics/unrealized/full.rs index 5b1d692f1..c6ad868e1 100644 --- a/crates/brk_computer/src/distribution/metrics/unrealized/full.rs +++ b/crates/brk_computer/src/distribution/metrics/unrealized/full.rs @@ -1,8 +1,8 @@ use brk_error::Result; use brk_traversable::Traversable; -use brk_types::{Cents, CentsSats, CentsSigned, Indexes, Version}; +use brk_types::{Cents, CentsSigned, Height, Indexes, Sats, Version}; use derive_more::{Deref, DerefMut}; -use vecdb::{AnyStoredVec, Exit, Rw, StorageMode, WritableVec}; +use vecdb::{AnyStoredVec, Exit, ReadableVec, Rw, StorageMode}; use crate::distribution::state::UnrealizedState; use crate::internal::{CentsSubtractToCentsSigned, FiatPerBlock}; @@ -26,11 +26,6 @@ pub struct UnrealizedFull { pub gross_pnl: FiatPerBlock, - #[traversable(wrap = "invested_capital", rename = "in_profit")] - pub invested_capital_in_profit: FiatPerBlock, - #[traversable(wrap = "invested_capital", rename = "in_loss")] - pub invested_capital_in_loss: FiatPerBlock, - pub sentiment: UnrealizedSentiment, } @@ -40,8 +35,6 @@ impl UnrealizedFull { let inner = UnrealizedBase::forced_import(cfg)?; let gross_pnl = cfg.import("unrealized_gross_pnl", v0)?; - let invested_capital_in_profit = cfg.import("invested_capital_in_profit", v0)?; - let invested_capital_in_loss = cfg.import("invested_capital_in_loss", v0)?; let sentiment = UnrealizedSentiment { pain_index: cfg.import("pain_index", v0)?, @@ -52,8 +45,6 @@ impl UnrealizedFull { Ok(Self { inner, gross_pnl, - invested_capital_in_profit, - invested_capital_in_loss, sentiment, }) } @@ -61,21 +52,11 @@ impl UnrealizedFull { #[inline(always)] pub(crate) fn push_state_all(&mut self, state: &UnrealizedState) { self.inner.push_state(state); - self.invested_capital_in_profit - .cents - .height - .push(state.invested_capital_in_profit); - self.invested_capital_in_loss - .cents - .height - .push(state.invested_capital_in_loss); } pub(crate) fn collect_vecs_mut(&mut self) -> Vec<&mut dyn AnyStoredVec> { let mut vecs = self.inner.collect_vecs_mut(); vecs.push(&mut self.gross_pnl.cents.height as &mut dyn AnyStoredVec); - vecs.push(&mut self.invested_capital_in_profit.cents.height as &mut dyn AnyStoredVec); - vecs.push(&mut self.invested_capital_in_loss.cents.height as &mut dyn AnyStoredVec); vecs.push(&mut self.sentiment.pain_index.cents.height as &mut dyn AnyStoredVec); vecs.push(&mut self.sentiment.greed_index.cents.height as &mut dyn AnyStoredVec); vecs.push(&mut self.sentiment.net.cents.height as &mut dyn AnyStoredVec); @@ -86,6 +67,8 @@ impl UnrealizedFull { &mut self, prices: &prices::Vecs, starting_indexes: &Indexes, + supply_in_profit_sats: &(impl ReadableVec + Sync), + supply_in_loss_sats: &(impl ReadableVec + Sync), exit: &Exit, ) -> Result<()> { self.inner.compute_rest(starting_indexes, exit)?; @@ -97,76 +80,8 @@ impl UnrealizedFull { exit, )?; - self.invested_capital_in_profit - .cents - .height - .compute_transform( - starting_indexes.height, - &self.inner.invested_capital_in_profit_raw, - |(h, raw, ..)| (h, CentsSats::to_cents(raw)), - exit, - )?; + self.compute_rest_extended(prices, starting_indexes, supply_in_profit_sats, supply_in_loss_sats, exit)?; - self.invested_capital_in_loss - .cents - .height - .compute_transform( - starting_indexes.height, - &self.inner.invested_capital_in_loss_raw, - |(h, raw, ..)| (h, CentsSats::to_cents(raw)), - exit, - )?; - - self.compute_rest_extended(prices, starting_indexes, exit)?; - Ok(()) - } - - fn compute_rest_extended( - &mut self, - prices: &prices::Vecs, - starting_indexes: &Indexes, - exit: &Exit, - ) -> Result<()> { - self.sentiment.pain_index.cents.height.compute_transform3( - starting_indexes.height, - &self.inner.investor_cap_in_loss_raw, - &self.inner.invested_capital_in_loss_raw, - &prices.spot.cents.height, - |(h, investor_cap, invested_cap, spot, ..)| { - if invested_cap.inner() == 0 { - return (h, Cents::ZERO); - } - let investor_price_losers = investor_cap.inner() / invested_cap.inner(); - let spot_u128 = spot.as_u128(); - (h, Cents::new((investor_price_losers - spot_u128) as u64)) - }, - exit, - )?; - - self.sentiment.greed_index.cents.height.compute_transform3( - starting_indexes.height, - &self.inner.investor_cap_in_profit_raw, - &self.inner.invested_capital_in_profit_raw, - &prices.spot.cents.height, - |(h, investor_cap, invested_cap, spot, ..)| { - if invested_cap.inner() == 0 { - return (h, Cents::ZERO); - } - let investor_price_winners = investor_cap.inner() / invested_cap.inner(); - let spot_u128 = spot.as_u128(); - (h, Cents::new((spot_u128 - investor_price_winners) as u64)) - }, - exit, - )?; - - Ok(()) - } - - pub(crate) fn compute_net_sentiment_height( - &mut self, - starting_indexes: &Indexes, - exit: &Exit, - ) -> Result<()> { self.sentiment .net .cents @@ -177,6 +92,53 @@ impl UnrealizedFull { &self.sentiment.pain_index.cents.height, exit, )?; + Ok(()) } + + fn compute_rest_extended( + &mut self, + prices: &prices::Vecs, + starting_indexes: &Indexes, + supply_in_profit_sats: &(impl ReadableVec + Sync), + supply_in_loss_sats: &(impl ReadableVec + Sync), + exit: &Exit, + ) -> Result<()> { + self.sentiment.greed_index.cents.height.compute_transform3( + starting_indexes.height, + &self.inner.investor_cap_in_profit_raw, + supply_in_profit_sats, + &prices.spot.cents.height, + |(h, investor_cap, supply_sats, spot, ..)| { + let invested_cap = supply_sats.as_u128() * spot.as_u128(); + if invested_cap == 0 { + return (h, Cents::ZERO); + } + let investor_price = investor_cap.inner() / invested_cap; + let spot_u128 = spot.as_u128(); + (h, Cents::new((spot_u128 - investor_price) as u64)) + }, + exit, + )?; + + self.sentiment.pain_index.cents.height.compute_transform3( + starting_indexes.height, + &self.inner.investor_cap_in_loss_raw, + supply_in_loss_sats, + &prices.spot.cents.height, + |(h, investor_cap, supply_sats, spot, ..)| { + let invested_cap = supply_sats.as_u128() * spot.as_u128(); + if invested_cap == 0 { + return (h, Cents::ZERO); + } + let investor_price = investor_cap.inner() / invested_cap; + let spot_u128 = spot.as_u128(); + (h, Cents::new((investor_price - spot_u128) as u64)) + }, + exit, + )?; + + Ok(()) + } + } diff --git a/crates/brk_computer/src/distribution/metrics/unrealized/mod.rs b/crates/brk_computer/src/distribution/metrics/unrealized/mod.rs index 2f5b2be46..4c59616e3 100644 --- a/crates/brk_computer/src/distribution/metrics/unrealized/mod.rs +++ b/crates/brk_computer/src/distribution/metrics/unrealized/mod.rs @@ -11,8 +11,8 @@ pub use full::UnrealizedFull; pub use minimal::UnrealizedMinimal; use brk_error::Result; -use brk_types::Indexes; -use vecdb::Exit; +use brk_types::{Height, Indexes, Sats}; +use vecdb::{Exit, ReadableVec}; use crate::{distribution::state::UnrealizedState, prices}; @@ -25,11 +25,8 @@ pub trait UnrealizedLike: Send + Sync { &mut self, prices: &prices::Vecs, starting_indexes: &Indexes, - exit: &Exit, - ) -> Result<()>; - fn compute_net_sentiment_height( - &mut self, - starting_indexes: &Indexes, + supply_in_profit_sats: &(impl ReadableVec + Sync), + supply_in_loss_sats: &(impl ReadableVec + Sync), exit: &Exit, ) -> Result<()>; } @@ -52,17 +49,12 @@ impl UnrealizedLike for UnrealizedBase { &mut self, _prices: &prices::Vecs, starting_indexes: &Indexes, + _supply_in_profit_sats: &(impl ReadableVec + Sync), + _supply_in_loss_sats: &(impl ReadableVec + Sync), exit: &Exit, ) -> Result<()> { self.compute_rest(starting_indexes, exit) } - fn compute_net_sentiment_height( - &mut self, - _starting_indexes: &Indexes, - _exit: &Exit, - ) -> Result<()> { - Ok(()) - } } impl UnrealizedLike for UnrealizedFull { @@ -83,15 +75,10 @@ impl UnrealizedLike for UnrealizedFull { &mut self, prices: &prices::Vecs, starting_indexes: &Indexes, + supply_in_profit_sats: &(impl ReadableVec + Sync), + supply_in_loss_sats: &(impl ReadableVec + Sync), exit: &Exit, ) -> Result<()> { - self.compute_rest_all(prices, starting_indexes, exit) - } - fn compute_net_sentiment_height( - &mut self, - starting_indexes: &Indexes, - exit: &Exit, - ) -> Result<()> { - self.compute_net_sentiment_height(starting_indexes, exit) + self.compute_rest_all(prices, starting_indexes, supply_in_profit_sats, supply_in_loss_sats, exit) } } diff --git a/crates/brk_computer/src/distribution/state/cost_basis/unrealized.rs b/crates/brk_computer/src/distribution/state/cost_basis/unrealized.rs index 2247d936d..4f7b4f51b 100644 --- a/crates/brk_computer/src/distribution/state/cost_basis/unrealized.rs +++ b/crates/brk_computer/src/distribution/state/cost_basis/unrealized.rs @@ -10,16 +10,10 @@ pub struct UnrealizedState { pub supply_in_loss: Sats, pub unrealized_profit: Cents, pub unrealized_loss: Cents, - pub invested_capital_in_profit: Cents, - pub invested_capital_in_loss: Cents, /// Raw Σ(price² × sats) for UTXOs in profit. Used for aggregation. pub investor_cap_in_profit_raw: u128, /// Raw Σ(price² × sats) for UTXOs in loss. Used for aggregation. pub investor_cap_in_loss_raw: u128, - /// Raw Σ(price × sats) for UTXOs in profit. Used for aggregation. - pub invested_capital_in_profit_raw: u128, - /// Raw Σ(price × sats) for UTXOs in loss. Used for aggregation. - pub invested_capital_in_loss_raw: u128, } impl UnrealizedState { @@ -28,12 +22,8 @@ impl UnrealizedState { supply_in_loss: Sats::ZERO, unrealized_profit: Cents::ZERO, unrealized_loss: Cents::ZERO, - invested_capital_in_profit: Cents::ZERO, - invested_capital_in_loss: Cents::ZERO, investor_cap_in_profit_raw: 0, investor_cap_in_loss_raw: 0, - invested_capital_in_profit_raw: 0, - invested_capital_in_loss_raw: 0, }; } @@ -118,12 +108,8 @@ impl Accumulate for WithoutCapital { impl Accumulate for WithCapital { fn to_output(&self) -> UnrealizedState { UnrealizedState { - invested_capital_in_profit: div_btc(self.invested_capital_in_profit), - invested_capital_in_loss: div_btc(self.invested_capital_in_loss), investor_cap_in_profit_raw: self.investor_cap_in_profit, investor_cap_in_loss_raw: self.investor_cap_in_loss, - invested_capital_in_profit_raw: self.invested_capital_in_profit, - invested_capital_in_loss_raw: self.invested_capital_in_loss, ..Accumulate::to_output(&self.core) } }