Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-06-18 02:39:43 -07:00
Code Issues Packages Projects Releases Wiki Activity

global: snapshot

Browse Source
This commit is contained in:
nym21
2025-05-28 16:53:18 +02:00
parent 9bbf3a027f
commit 99818924ee
32 changed files with 171 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_computer/src/lib.rs
-1
View File
@@ -11,7 +11,6 @@ use brk_fetcher::Fetcher;
use brk_indexer::Indexer;
use brk_vec::{AnyCollectableVec, Compressed, Computation};
mod states;
mod stores;
mod utils;
mod vecs;
crates/brk_computer/src/states/block.rs
-32
View File
@@ -1,32 +0,0 @@
use std::ops::{Add, AddAssign, SubAssign};
use brk_core::{Dollars, Timestamp};
use super::SupplyState;
#[derive(Debug, Clone)]
pub struct BlockState {
pub supply: SupplyState,
pub price: Option<Dollars>,
pub timestamp: Timestamp,
}
impl Add<BlockState> for BlockState {
type Output = Self;
fn add(mut self, rhs: BlockState) -> Self::Output {
self.supply += &rhs.supply;
self
}
}
impl AddAssign<&BlockState> for BlockState {
fn add_assign(&mut self, rhs: &Self) {
self.supply += &rhs.supply;
}
}
impl SubAssign<&BlockState> for BlockState {
fn sub_assign(&mut self, rhs: &Self) {
self.supply -= &rhs.supply;
}
}
crates/brk_computer/src/states/cohort.rs
-57
View File
@@ -1,57 +0,0 @@
use brk_core::Dollars;
use super::{RealizedState, SupplyState};
#[derive(Debug, Default, Clone)]
pub struct CohortState {
pub supply: SupplyState,
pub realized: Option<RealizedState>,
// pub price_to_amount: PriceToValue<Amount>, save it not rounded in fjall
}
impl CohortState {
pub fn reset_single_iteration_values(&mut self) {
if let Some(realized) = self.realized.as_mut() {
realized.reset_single_iteration_values();
}
}
pub fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
self.supply += supply_state;
if let Some(realized) = self.realized.as_mut() {
realized.increment(supply_state, price.unwrap());
}
}
pub fn decrement(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
self.supply -= supply_state;
if let Some(realized) = self.realized.as_mut() {
realized.decrement(supply_state, price.unwrap());
}
}
pub fn receive(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
self.supply += supply_state;
if let Some(realized) = self.realized.as_mut() {
realized.receive(supply_state, price.unwrap());
}
}
pub fn send(
&mut self,
supply_state: &SupplyState,
current_price: Option<Dollars>,
prev_price: Option<Dollars>,
older_than_hour: bool,
) {
self.supply -= supply_state;
if let Some(realized) = self.realized.as_mut() {
realized.send(
supply_state,
current_price.unwrap(),
prev_price.unwrap(),
older_than_hour,
);
}
}
}
crates/brk_computer/src/states/hot.rs
-142
View File
@@ -1,142 +0,0 @@
pub struct OneShotSats {
pub price_paid_state: PricePaidState,
pub unrealized_block_state: UnrealizedState,
pub unrealized_date_state: Option<UnrealizedState>,
}
pub struct UnrealizedState {
supply_in_profit: Sats,
// supply_in_loss: Sats,
unrealized_profit: Dollars,
unrealized_loss: Dollars,
}
// Why option ?
#[derive(Default, Debug)]
pub struct PricePaidState {
pp_p5: Option<Dollars>,
pp_p10: Option<Dollars>,
pp_p15: Option<Dollars>,
pp_p20: Option<Dollars>,
pp_p25: Option<Dollars>,
pp_p30: Option<Dollars>,
pp_p35: Option<Dollars>,
pp_p40: Option<Dollars>,
pp_p45: Option<Dollars>,
pp_median: Option<Dollars>,
pp_p55: Option<Dollars>,
pp_p60: Option<Dollars>,
pp_p65: Option<Dollars>,
pp_p70: Option<Dollars>,
pp_p75: Option<Dollars>,
pp_p80: Option<Dollars>,
pp_p85: Option<Dollars>,
pp_p90: Option<Dollars>,
pp_p95: Option<Dollars>,
processed_amount: Sats,
}
pub struct PricePaidStateFull {
pp_p1: Option<Dollars>,
pp_p2: Option<Dollars>,
pp_p3: Option<Dollars>,
pp_p4: Option<Dollars>,
pp_p5: Option<Dollars>,
pp_p6: Option<Dollars>,
pp_p7: Option<Dollars>,
pp_p8: Option<Dollars>,
pp_p9: Option<Dollars>,
pp_p10: Option<Dollars>,
pp_p11: Option<Dollars>,
pp_p12: Option<Dollars>,
pp_p13: Option<Dollars>,
pp_p14: Option<Dollars>,
pp_p15: Option<Dollars>,
pp_p16: Option<Dollars>,
pp_p17: Option<Dollars>,
pp_p18: Option<Dollars>,
pp_p19: Option<Dollars>,
pp_p20: Option<Dollars>,
pp_p21: Option<Dollars>,
pp_p22: Option<Dollars>,
pp_p23: Option<Dollars>,
pp_p24: Option<Dollars>,
pp_p25: Option<Dollars>,
pp_p26: Option<Dollars>,
pp_p27: Option<Dollars>,
pp_p28: Option<Dollars>,
pp_p29: Option<Dollars>,
pp_p30: Option<Dollars>,
pp_p31: Option<Dollars>,
pp_p32: Option<Dollars>,
pp_p33: Option<Dollars>,
pp_p34: Option<Dollars>,
pp_p35: Option<Dollars>,
pp_p36: Option<Dollars>,
pp_p37: Option<Dollars>,
pp_p38: Option<Dollars>,
pp_p39: Option<Dollars>,
pp_p40: Option<Dollars>,
pp_p41: Option<Dollars>,
pp_p42: Option<Dollars>,
pp_p43: Option<Dollars>,
pp_p44: Option<Dollars>,
pp_p45: Option<Dollars>,
pp_p46: Option<Dollars>,
pp_p47: Option<Dollars>,
pp_p48: Option<Dollars>,
pp_p49: Option<Dollars>,
pp_p50: Option<Dollars>,
pp_p51: Option<Dollars>,
pp_p52: Option<Dollars>,
pp_p53: Option<Dollars>,
pp_p54: Option<Dollars>,
pp_p55: Option<Dollars>,
pp_p56: Option<Dollars>,
pp_p57: Option<Dollars>,
pp_p58: Option<Dollars>,
pp_p59: Option<Dollars>,
pp_p60: Option<Dollars>,
pp_p61: Option<Dollars>,
pp_p62: Option<Dollars>,
pp_p63: Option<Dollars>,
pp_p64: Option<Dollars>,
pp_p65: Option<Dollars>,
pp_p66: Option<Dollars>,
pp_p67: Option<Dollars>,
pp_p68: Option<Dollars>,
pp_p69: Option<Dollars>,
pp_p70: Option<Dollars>,
pp_p71: Option<Dollars>,
pp_p72: Option<Dollars>,
pp_p73: Option<Dollars>,
pp_p74: Option<Dollars>,
pp_p75: Option<Dollars>,
pp_p76: Option<Dollars>,
pp_p77: Option<Dollars>,
pp_p78: Option<Dollars>,
pp_p79: Option<Dollars>,
pp_p80: Option<Dollars>,
pp_p81: Option<Dollars>,
pp_p82: Option<Dollars>,
pp_p83: Option<Dollars>,
pp_p84: Option<Dollars>,
pp_p85: Option<Dollars>,
pp_p86: Option<Dollars>,
pp_p87: Option<Dollars>,
pp_p88: Option<Dollars>,
pp_p89: Option<Dollars>,
pp_p90: Option<Dollars>,
pp_p91: Option<Dollars>,
pp_p92: Option<Dollars>,
pp_p93: Option<Dollars>,
pp_p94: Option<Dollars>,
pp_p95: Option<Dollars>,
pp_p96: Option<Dollars>,
pp_p97: Option<Dollars>,
pp_p98: Option<Dollars>,
pp_p99: Option<Dollars>,
processed_amount: Sats,
}
crates/brk_computer/src/states/mod.rs
-15
View File
@@ -1,15 +0,0 @@
mod block;
mod cohort;
mod outputs;
mod realized;
// mod hot;
mod supply;
mod transacted;
pub use block::*;
pub use cohort::*;
pub use outputs::*;
pub use realized::*;
// pub use hot::*;
pub use supply::*;
pub use transacted::*;
crates/brk_computer/src/states/outputs/by_epoch.rs
-59
View File
@@ -1,59 +0,0 @@
use brk_core::{HalvingEpoch, Height};
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByEpoch<T> {
pub _0: T,
pub _1: T,
pub _2: T,
pub _3: T,
pub _4: T,
}
impl<T> From<OutputsByEpoch<T>> for OutputsByEpoch<(OutputFilter, T)> {
fn from(value: OutputsByEpoch<T>) -> Self {
Self {
_0: (OutputFilter::Epoch(HalvingEpoch::new(0)), value._0),
_1: (OutputFilter::Epoch(HalvingEpoch::new(1)), value._1),
_2: (OutputFilter::Epoch(HalvingEpoch::new(2)), value._2),
_3: (OutputFilter::Epoch(HalvingEpoch::new(3)), value._3),
_4: (OutputFilter::Epoch(HalvingEpoch::new(4)), value._4),
}
}
}
impl<T> OutputsByEpoch<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 5] {
[
&mut self._0,
&mut self._1,
&mut self._2,
&mut self._3,
&mut self._4,
]
}
pub fn mut_vec_from_height(&mut self, height: Height) -> &mut T {
let epoch = HalvingEpoch::from(height);
if epoch == HalvingEpoch::new(0) {
&mut self._0
} else if epoch == HalvingEpoch::new(1) {
&mut self._1
} else if epoch == HalvingEpoch::new(2) {
&mut self._2
} else if epoch == HalvingEpoch::new(3) {
&mut self._3
} else if epoch == HalvingEpoch::new(4) {
&mut self._4
} else {
todo!("")
}
}
}
impl<T> OutputsByEpoch<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 5] {
[&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1]
}
}
crates/brk_computer/src/states/outputs/by_from.rs
-98
View File
@@ -1,98 +0,0 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByFrom<T> {
pub _1d: T,
pub _1w: T,
pub _1m: T,
pub _2m: T,
pub _3m: T,
pub _4m: T,
pub _5m: T,
pub _6m: T,
pub _1y: T,
pub _2y: T,
pub _3y: T,
pub _4y: T,
pub _5y: T,
pub _6y: T,
pub _7y: T,
pub _8y: T,
pub _10y: T,
pub _15y: T,
}
impl<T> OutputsByFrom<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
[
&mut self._1d,
&mut self._1w,
&mut self._1m,
&mut self._2m,
&mut self._3m,
&mut self._4m,
&mut self._5m,
&mut self._6m,
&mut self._1y,
&mut self._2y,
&mut self._3y,
&mut self._4y,
&mut self._5y,
&mut self._6y,
&mut self._7y,
&mut self._8y,
&mut self._10y,
&mut self._15y,
]
}
}
impl<T> OutputsByFrom<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 18] {
[
&self._1d.1,
&self._1w.1,
&self._1m.1,
&self._2m.1,
&self._3m.1,
&self._4m.1,
&self._5m.1,
&self._6m.1,
&self._1y.1,
&self._2y.1,
&self._3y.1,
&self._4y.1,
&self._5y.1,
&self._6y.1,
&self._7y.1,
&self._8y.1,
&self._10y.1,
&self._15y.1,
]
}
}
impl<T> From<OutputsByFrom<T>> for OutputsByFrom<(OutputFilter, T)> {
fn from(value: OutputsByFrom<T>) -> Self {
Self {
_1d: (OutputFilter::From(1), value._1d),
_1w: (OutputFilter::From(7), value._1w),
_1m: (OutputFilter::From(30), value._1m),
_2m: (OutputFilter::From(2 * 30), value._2m),
_3m: (OutputFilter::From(3 * 30), value._3m),
_4m: (OutputFilter::From(4 * 30), value._4m),
_5m: (OutputFilter::From(5 * 30), value._5m),
_6m: (OutputFilter::From(6 * 30), value._6m),
_1y: (OutputFilter::From(365), value._1y),
_2y: (OutputFilter::From(2 * 365), value._2y),
_3y: (OutputFilter::From(3 * 365), value._3y),
_4y: (OutputFilter::From(4 * 365), value._4y),
_5y: (OutputFilter::From(5 * 365), value._5y),
_6y: (OutputFilter::From(6 * 365), value._6y),
_7y: (OutputFilter::From(7 * 365), value._7y),
_8y: (OutputFilter::From(8 * 365), value._8y),
_10y: (OutputFilter::From(10 * 365), value._10y),
_15y: (OutputFilter::From(15 * 365), value._15y),
}
}
}
crates/brk_computer/src/states/outputs/by_range.rs
-74
View File
@@ -1,74 +0,0 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByRange<T> {
pub _1d_to_1w: T,
pub _1w_to_1m: T,
pub _1m_to_3m: T,
pub _3m_to_6m: T,
pub _6m_to_1y: T,
pub _1y_to_2y: T,
pub _2y_to_3y: T,
pub _3y_to_4y: T,
pub _4y_to_5y: T,
pub _5y_to_7y: T,
pub _7y_to_10y: T,
pub _10y_to_15y: T,
}
impl<T> From<OutputsByRange<T>> for OutputsByRange<(OutputFilter, T)> {
fn from(value: OutputsByRange<T>) -> Self {
Self {
_1d_to_1w: (OutputFilter::Range(1..7), value._1d_to_1w),
_1w_to_1m: (OutputFilter::Range(7..30), value._1w_to_1m),
_1m_to_3m: (OutputFilter::Range(30..3 * 30), value._1m_to_3m),
_3m_to_6m: (OutputFilter::Range(3 * 30..6 * 30), value._3m_to_6m),
_6m_to_1y: (OutputFilter::Range(6 * 30..365), value._6m_to_1y),
_1y_to_2y: (OutputFilter::Range(365..2 * 365), value._1y_to_2y),
_2y_to_3y: (OutputFilter::Range(2 * 365..3 * 365), value._2y_to_3y),
_3y_to_4y: (OutputFilter::Range(3 * 365..4 * 365), value._3y_to_4y),
_4y_to_5y: (OutputFilter::Range(4 * 365..5 * 365), value._4y_to_5y),
_5y_to_7y: (OutputFilter::Range(5 * 365..7 * 365), value._5y_to_7y),
_7y_to_10y: (OutputFilter::Range(7 * 365..10 * 365), value._7y_to_10y),
_10y_to_15y: (OutputFilter::Range(10 * 365..15 * 365), value._10y_to_15y),
}
}
}
impl<T> OutputsByRange<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 12] {
[
&mut self._1d_to_1w,
&mut self._1w_to_1m,
&mut self._1m_to_3m,
&mut self._3m_to_6m,
&mut self._6m_to_1y,
&mut self._1y_to_2y,
&mut self._2y_to_3y,
&mut self._3y_to_4y,
&mut self._4y_to_5y,
&mut self._5y_to_7y,
&mut self._7y_to_10y,
&mut self._10y_to_15y,
]
}
}
impl<T> OutputsByRange<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 12] {
[
&self._1d_to_1w.1,
&self._1w_to_1m.1,
&self._1m_to_3m.1,
&self._3m_to_6m.1,
&self._6m_to_1y.1,
&self._1y_to_2y.1,
&self._2y_to_3y.1,
&self._3y_to_4y.1,
&self._4y_to_5y.1,
&self._5y_to_7y.1,
&self._7y_to_10y.1,
&self._10y_to_15y.1,
]
}
}
crates/brk_computer/src/states/outputs/by_size.rs
-182
View File
@@ -1,182 +0,0 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsBySize<T> {
pub _0sat: T,
pub from_1sat_to_10sats: T,
pub from_10sats_to_100sats: T,
pub from_100sats_to_1_000sats: T,
pub from_1_000sats_to_10_000sats: T,
pub from_10_000sats_to_100_000sats: T,
pub from_100_000sats_to_1_000_000sats: T,
pub from_1_000_000sats_to_10_000_000sats: T,
pub from_10_000_000sats_to_1btc: T,
pub from_1btc_to_10btc: T,
pub from_10btc_to_100btc: T,
pub from_100btc_to_1_000btc: T,
pub from_1_000btc_to_10_000btc: T,
pub from_10_000btc_to_100_000btc: T,
pub from_100_000btc: T,
}
impl<T> From<OutputsBySize<T>> for OutputsBySize<(OutputFilter, T)> {
fn from(value: OutputsBySize<T>) -> Self {
#[allow(clippy::inconsistent_digit_grouping)]
Self {
_0sat: (
// OutputFilter::Zero,
OutputFilter::Size,
value._0sat,
),
from_1sat_to_10sats: (
// OutputFilter::Size(Sats::new(1)..Sats::new(10)),
OutputFilter::Size,
value.from_1sat_to_10sats,
),
from_10sats_to_100sats: (
// OutputFilter::Size(Sats::new(10)..Sats::new(100)),
OutputFilter::Size,
value.from_10sats_to_100sats,
),
from_100sats_to_1_000sats: (
// OutputFilter::Size(Sats::new(100)..Sats::new(1_000)),
OutputFilter::Size,
value.from_100sats_to_1_000sats,
),
from_1_000sats_to_10_000sats: (
// OutputFilter::Size(Sats::new(1_000)..Sats::new(10_000)),
OutputFilter::Size,
value.from_1_000sats_to_10_000sats,
),
from_10_000sats_to_100_000sats: (
// OutputFilter::Size(Sats::new(10_000)..Sats::new(100_000)),
OutputFilter::Size,
value.from_10_000sats_to_100_000sats,
),
from_100_000sats_to_1_000_000sats: (
// OutputFilter::Size(Sats::new(100_000)..Sats::new(1_000_000)),
OutputFilter::Size,
value.from_100_000sats_to_1_000_000sats,
),
from_1_000_000sats_to_10_000_000sats: (
// OutputFilter::Size(Sats::new(1_000_000)..Sats::new(10_000_000)),
OutputFilter::Size,
value.from_1_000_000sats_to_10_000_000sats,
),
from_10_000_000sats_to_1btc: (
// OutputFilter::Size(Sats::new(10_000_000)..Sats::new(1_00_000_000)),
OutputFilter::Size,
value.from_10_000_000sats_to_1btc,
),
from_1btc_to_10btc: (
// OutputFilter::Size(Sats::new(1_00_000_000)..Sats::new(10_00_000_000)),
OutputFilter::Size,
value.from_1btc_to_10btc,
),
from_10btc_to_100btc: (
// OutputFilter::Size(Sats::new(10_00_000_000)..Sats::new(100_00_000_000)),
OutputFilter::Size,
value.from_10btc_to_100btc,
),
from_100btc_to_1_000btc: (
// OutputFilter::Size(Sats::new(100_00_000_000)..Sats::new(1_000_00_000_000)),
OutputFilter::Size,
value.from_100btc_to_1_000btc,
),
from_1_000btc_to_10_000btc: (
// OutputFilter::Size(Sats::new(1_000_00_000_000)..Sats::new(10_000_00_000_000)),
OutputFilter::Size,
value.from_1_000btc_to_10_000btc,
),
from_10_000btc_to_100_000btc: (
// OutputFilter::Size(Sats::new(10_000_00_000_000)..Sats::new(100_000_00_000_000)),
OutputFilter::Size,
value.from_10_000btc_to_100_000btc,
),
from_100_000btc: (
// OutputFilter::Size(Sats::new(100_000_00_000_000)..Sats::MAX),
OutputFilter::Size,
value.from_100_000btc,
),
}
}
}
impl<T> OutputsBySize<T> {
#[allow(clippy::inconsistent_digit_grouping)]
pub fn get_mut(&mut self, group: usize) -> &mut T {
if group == 0 {
&mut self._0sat
} else if group == 1 {
&mut self.from_1sat_to_10sats
} else if group == 10 {
&mut self.from_10sats_to_100sats
} else if group == 100 {
&mut self.from_100sats_to_1_000sats
} else if group == 1_000 {
&mut self.from_1_000sats_to_10_000sats
} else if group == 10_000 {
&mut self.from_10_000sats_to_100_000sats
} else if group == 100_000 {
&mut self.from_100_000sats_to_1_000_000sats
} else if group == 1_000_000 {
&mut self.from_1_000_000sats_to_10_000_000sats
} else if group == 10_000_000 {
&mut self.from_10_000_000sats_to_1btc
} else if group == 1_00_000_000 {
&mut self.from_1btc_to_10btc
} else if group == 10_00_000_000 {
&mut self.from_10btc_to_100btc
} else if group == 100_00_000_000 {
&mut self.from_100btc_to_1_000btc
} else if group == 1_000_00_000_000 {
&mut self.from_1_000btc_to_10_000btc
} else if group == 10_000_00_000_000 {
&mut self.from_10_000btc_to_100_000btc
} else {
&mut self.from_100_000btc
}
}
pub fn as_mut_vec(&mut self) -> [&mut T; 15] {
[
&mut self._0sat,
&mut self.from_1sat_to_10sats,
&mut self.from_10sats_to_100sats,
&mut self.from_100sats_to_1_000sats,
&mut self.from_1_000sats_to_10_000sats,
&mut self.from_10_000sats_to_100_000sats,
&mut self.from_100_000sats_to_1_000_000sats,
&mut self.from_1_000_000sats_to_10_000_000sats,
&mut self.from_10_000_000sats_to_1btc,
&mut self.from_1btc_to_10btc,
&mut self.from_10btc_to_100btc,
&mut self.from_100btc_to_1_000btc,
&mut self.from_1_000btc_to_10_000btc,
&mut self.from_10_000btc_to_100_000btc,
&mut self.from_100_000btc,
]
}
}
impl<T> OutputsBySize<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 15] {
[
&self._0sat.1,
&self.from_1sat_to_10sats.1,
&self.from_10sats_to_100sats.1,
&self.from_100sats_to_1_000sats.1,
&self.from_1_000sats_to_10_000sats.1,
&self.from_10_000sats_to_100_000sats.1,
&self.from_100_000sats_to_1_000_000sats.1,
&self.from_1_000_000sats_to_10_000_000sats.1,
&self.from_10_000_000sats_to_1btc.1,
&self.from_1btc_to_10btc.1,
&self.from_10btc_to_100btc.1,
&self.from_100btc_to_1_000btc.1,
&self.from_1_000btc_to_10_000btc.1,
&self.from_10_000btc_to_100_000btc.1,
&self.from_100_000btc.1,
]
}
}
crates/brk_computer/src/states/outputs/by_spendable_type.rs
-181
View File
@@ -1,181 +0,0 @@
use std::ops::{Add, AddAssign};
use brk_core::OutputType;
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsBySpendableType<T> {
pub p2pk65: T,
pub p2pk33: T,
pub p2pkh: T,
pub p2ms: T,
pub p2sh: T,
pub p2wpkh: T,
pub p2wsh: T,
pub p2tr: T,
pub p2a: T,
pub unknown: T,
pub empty: T,
}
impl<T> OutputsBySpendableType<T> {
// pub fn get(&self, output_type: OutputType) -> &T {
// match output_type {
// OutputType::P2PK65 => &self.p2pk65,
// OutputType::P2PK33 => &self.p2pk33,
// OutputType::P2PKH => &self.p2pkh,
// OutputType::P2MS => &self.p2ms,
// OutputType::P2SH => &self.p2sh,
// OutputType::P2WPKH => &self.p2wpkh,
// OutputType::P2WSH => &self.p2wsh,
// OutputType::P2TR => &self.p2tr,
// OutputType::P2A => &self.p2a,
// OutputType::Unknown => &self.unknown,
// OutputType::Empty => &self.empty,
// _ => unreachable!(),
// }
// }
pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
match output_type {
OutputType::P2PK65 => &mut self.p2pk65,
OutputType::P2PK33 => &mut self.p2pk33,
OutputType::P2PKH => &mut self.p2pkh,
OutputType::P2MS => &mut self.p2ms,
OutputType::P2SH => &mut self.p2sh,
OutputType::P2WPKH => &mut self.p2wpkh,
OutputType::P2WSH => &mut self.p2wsh,
OutputType::P2TR => &mut self.p2tr,
OutputType::P2A => &mut self.p2a,
OutputType::Unknown => &mut self.unknown,
OutputType::Empty => &mut self.empty,
_ => unreachable!(),
}
}
// pub fn as_vec(&self) -> [&T; 11] {
// [
// &self.p2pk65,
// &self.p2pk33,
// &self.p2pkh,
// &self.p2ms,
// &self.p2sh,
// &self.p2wpkh,
// &self.p2wsh,
// &self.p2tr,
// &self.p2a,
// &self.unknown,
// &self.empty,
// ]
// }
pub fn as_mut_vec(&mut self) -> [&mut T; 11] {
[
&mut self.p2pk65,
&mut self.p2pk33,
&mut self.p2pkh,
&mut self.p2ms,
&mut self.p2sh,
&mut self.p2wpkh,
&mut self.p2wsh,
&mut self.p2tr,
&mut self.p2a,
&mut self.unknown,
&mut self.empty,
]
}
pub fn as_typed_vec(&self) -> [(OutputType, &T); 11] {
[
(OutputType::P2PK65, &self.p2pk65),
(OutputType::P2PK33, &self.p2pk33),
(OutputType::P2PKH, &self.p2pkh),
(OutputType::P2MS, &self.p2ms),
(OutputType::P2SH, &self.p2sh),
(OutputType::P2WPKH, &self.p2wpkh),
(OutputType::P2WSH, &self.p2wsh),
(OutputType::P2TR, &self.p2tr),
(OutputType::P2A, &self.p2a),
(OutputType::Unknown, &self.unknown),
(OutputType::Empty, &self.empty),
]
}
}
impl<T> OutputsBySpendableType<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 11] {
[
&self.p2pk65.1,
&self.p2pk33.1,
&self.p2pkh.1,
&self.p2ms.1,
&self.p2sh.1,
&self.p2wpkh.1,
&self.p2wsh.1,
&self.p2tr.1,
&self.p2a.1,
&self.unknown.1,
&self.empty.1,
]
}
}
impl<T> From<OutputsBySpendableType<T>> for OutputsBySpendableType<(OutputFilter, T)> {
fn from(value: OutputsBySpendableType<T>) -> Self {
Self {
p2pk65: (OutputFilter::Type(OutputType::P2PK65), value.p2pk65),
p2pk33: (OutputFilter::Type(OutputType::P2PK33), value.p2pk33),
p2pkh: (OutputFilter::Type(OutputType::P2PKH), value.p2pkh),
p2ms: (OutputFilter::Type(OutputType::P2MS), value.p2ms),
p2sh: (OutputFilter::Type(OutputType::P2SH), value.p2sh),
p2wpkh: (OutputFilter::Type(OutputType::P2WPKH), value.p2wpkh),
p2wsh: (OutputFilter::Type(OutputType::P2WSH), value.p2wsh),
p2tr: (OutputFilter::Type(OutputType::P2TR), value.p2tr),
p2a: (OutputFilter::Type(OutputType::P2A), value.p2a),
unknown: (OutputFilter::Type(OutputType::Unknown), value.unknown),
empty: (OutputFilter::Type(OutputType::Empty), value.empty),
}
}
}
impl<T> Add for OutputsBySpendableType<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
p2pk65: self.p2pk65 + rhs.p2pk65,
p2pk33: self.p2pk33 + rhs.p2pk33,
p2pkh: self.p2pkh + rhs.p2pkh,
p2ms: self.p2ms + rhs.p2ms,
p2sh: self.p2sh + rhs.p2sh,
p2wpkh: self.p2wpkh + rhs.p2wpkh,
p2wsh: self.p2wsh + rhs.p2wsh,
p2tr: self.p2tr + rhs.p2tr,
p2a: self.p2a + rhs.p2a,
unknown: self.unknown + rhs.unknown,
empty: self.empty + rhs.empty,
}
}
}
impl<T> AddAssign for OutputsBySpendableType<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self.p2pk65 += rhs.p2pk65;
self.p2pk33 += rhs.p2pk33;
self.p2pkh += rhs.p2pkh;
self.p2ms += rhs.p2ms;
self.p2sh += rhs.p2sh;
self.p2wpkh += rhs.p2wpkh;
self.p2wsh += rhs.p2wsh;
self.p2tr += rhs.p2tr;
self.p2a += rhs.p2a;
self.unknown += rhs.unknown;
self.empty += rhs.empty;
}
}
crates/brk_computer/src/states/outputs/by_term.rs
-28
View File
@@ -1,28 +0,0 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByTerm<T> {
pub short: T,
pub long: T,
}
impl<T> OutputsByTerm<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 2] {
[&mut self.short, &mut self.long]
}
}
impl<T> OutputsByTerm<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 2] {
[&self.short.1, &self.long.1]
}
}
impl<T> From<OutputsByTerm<T>> for OutputsByTerm<(OutputFilter, T)> {
fn from(value: OutputsByTerm<T>) -> Self {
Self {
long: (OutputFilter::From(155), value.long),
short: (OutputFilter::To(155), value.short),
}
}
}
crates/brk_computer/src/states/outputs/by_type.rs
-86
View File
@@ -1,86 +0,0 @@
use std::ops::{Add, AddAssign};
use brk_core::OutputType;
use super::{OutputsBySpendableType, OutputsByUnspendableType};
#[derive(Default, Clone)]
pub struct OutputsByType<T> {
pub spendable: OutputsBySpendableType<T>,
pub unspendable: OutputsByUnspendableType<T>,
}
impl<T> OutputsByType<T> {
pub fn get(&self, output_type: OutputType) -> &T {
match output_type {
OutputType::P2PK65 => &self.spendable.p2pk65,
OutputType::P2PK33 => &self.spendable.p2pk33,
OutputType::P2PKH => &self.spendable.p2pkh,
OutputType::P2MS => &self.spendable.p2ms,
OutputType::P2SH => &self.spendable.p2sh,
OutputType::P2WPKH => &self.spendable.p2wpkh,
OutputType::P2WSH => &self.spendable.p2wsh,
OutputType::P2TR => &self.spendable.p2tr,
OutputType::P2A => &self.spendable.p2a,
OutputType::Empty => &self.spendable.empty,
OutputType::Unknown => &self.spendable.unknown,
OutputType::OpReturn => &self.unspendable.opreturn,
}
}
pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
match output_type {
OutputType::P2PK65 => &mut self.spendable.p2pk65,
OutputType::P2PK33 => &mut self.spendable.p2pk33,
OutputType::P2PKH => &mut self.spendable.p2pkh,
OutputType::P2MS => &mut self.spendable.p2ms,
OutputType::P2SH => &mut self.spendable.p2sh,
OutputType::P2WPKH => &mut self.spendable.p2wpkh,
OutputType::P2WSH => &mut self.spendable.p2wsh,
OutputType::P2TR => &mut self.spendable.p2tr,
OutputType::P2A => &mut self.spendable.p2a,
OutputType::Unknown => &mut self.spendable.unknown,
OutputType::Empty => &mut self.spendable.empty,
OutputType::OpReturn => &mut self.unspendable.opreturn,
}
}
// pub fn as_vec(&self) -> Vec<&T> {
// self.spendable
// .as_vec()
// .into_iter()
// .chain(self.unspendable.as_vec())
// .collect::<Vec<_>>()
// }
// pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
// self.spendable
// .as_mut_vec()
// .into_iter()
// .chain(self.unspendable.as_mut_vec())
// .collect::<Vec<_>>()
// }
}
impl<T> Add for OutputsByType<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
spendable: self.spendable + rhs.spendable,
unspendable: self.unspendable + rhs.unspendable,
}
}
}
impl<T> AddAssign for OutputsByType<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self.spendable += rhs.spendable;
self.unspendable += rhs.unspendable;
}
}
crates/brk_computer/src/states/outputs/by_unspendable_type.rs
-33
View File
@@ -1,33 +0,0 @@
use std::ops::{Add, AddAssign};
#[derive(Default, Clone)]
pub struct OutputsByUnspendableType<T> {
pub opreturn: T,
}
impl<T> OutputsByUnspendableType<T> {
pub fn as_vec(&self) -> [&T; 1] {
[&self.opreturn]
}
}
impl<T> Add for OutputsByUnspendableType<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
opreturn: self.opreturn + rhs.opreturn,
}
}
}
impl<T> AddAssign for OutputsByUnspendableType<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self.opreturn += rhs.opreturn;
}
}
crates/brk_computer/src/states/outputs/by_up_to.rs
-98
View File
@@ -1,98 +0,0 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByUpTo<T> {
pub _1d: T,
pub _1w: T,
pub _1m: T,
pub _2m: T,
pub _3m: T,
pub _4m: T,
pub _5m: T,
pub _6m: T,
pub _1y: T,
pub _2y: T,
pub _3y: T,
pub _4y: T,
pub _5y: T,
pub _6y: T,
pub _7y: T,
pub _8y: T,
pub _10y: T,
pub _15y: T,
}
impl<T> OutputsByUpTo<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
[
&mut self._1d,
&mut self._1w,
&mut self._1m,
&mut self._2m,
&mut self._3m,
&mut self._4m,
&mut self._5m,
&mut self._6m,
&mut self._1y,
&mut self._2y,
&mut self._3y,
&mut self._4y,
&mut self._5y,
&mut self._6y,
&mut self._7y,
&mut self._8y,
&mut self._10y,
&mut self._15y,
]
}
}
impl<T> OutputsByUpTo<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 18] {
[
&self._1d.1,
&self._1w.1,
&self._1m.1,
&self._2m.1,
&self._3m.1,
&self._4m.1,
&self._5m.1,
&self._6m.1,
&self._1y.1,
&self._2y.1,
&self._3y.1,
&self._4y.1,
&self._5y.1,
&self._6y.1,
&self._7y.1,
&self._8y.1,
&self._10y.1,
&self._15y.1,
]
}
}
impl<T> From<OutputsByUpTo<T>> for OutputsByUpTo<(OutputFilter, T)> {
fn from(value: OutputsByUpTo<T>) -> Self {
Self {
_1d: (OutputFilter::To(1), value._1d),
_1w: (OutputFilter::To(7), value._1w),
_1m: (OutputFilter::To(30), value._1m),
_2m: (OutputFilter::To(2 * 30), value._2m),
_3m: (OutputFilter::To(3 * 30), value._3m),
_4m: (OutputFilter::To(4 * 30), value._4m),
_5m: (OutputFilter::To(5 * 30), value._5m),
_6m: (OutputFilter::To(6 * 30), value._6m),
_1y: (OutputFilter::To(365), value._1y),
_2y: (OutputFilter::To(2 * 365), value._2y),
_3y: (OutputFilter::To(3 * 365), value._3y),
_4y: (OutputFilter::To(4 * 365), value._4y),
_5y: (OutputFilter::To(5 * 365), value._5y),
_6y: (OutputFilter::To(6 * 365), value._6y),
_7y: (OutputFilter::To(7 * 365), value._7y),
_8y: (OutputFilter::To(8 * 365), value._8y),
_10y: (OutputFilter::To(10 * 365), value._10y),
_15y: (OutputFilter::To(15 * 365), value._15y),
}
}
}
crates/brk_computer/src/states/outputs/by_value.rs
-37
View File
@@ -1,37 +0,0 @@
#[derive(Default, Clone)]
pub struct OutputsByValue<T> {
pub up_to_1cent: T,
pub from_1c_to_10c: T,
pub from_10c_to_1d: T,
pub from_1d_to_10d: T,
pub from_10usd_to_100usd: T,
pub from_100usd_to_1_000usd: T,
pub from_1_000usd_to_10_000usd: T,
pub from_10_000usd_to_100_000usd: T,
pub from_100_000usd_to_1_000_000usd: T,
pub from_1_000_000usd_to_10_000_000usd: T,
pub from_10_000_000usd_to_100_000_000usd: T,
pub from_100_000_000usd_to_1_000_000_000usd: T,
pub from_1_000_000_000usd: T,
// ...
}
impl<T> OutputsByValue<T> {
pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
vec![
&mut self.up_to_1cent,
&mut self.from_1c_to_10c,
&mut self.from_10c_to_1d,
&mut self.from_1d_to_10d,
&mut self.from_10usd_to_100usd,
&mut self.from_100usd_to_1_000usd,
&mut self.from_1_000usd_to_10_000usd,
&mut self.from_10_000usd_to_100_000usd,
&mut self.from_100_000usd_to_1_000_000usd,
&mut self.from_1_000_000usd_to_10_000_000usd,
&mut self.from_10_000_000usd_to_100_000_000usd,
&mut self.from_100_000_000usd_to_1_000_000_000usd,
&mut self.from_1_000_000_000usd,
]
}
}
crates/brk_computer/src/states/outputs/filter.rs
-14
View File
@@ -1,14 +0,0 @@
use std::ops::Range;
use brk_core::{HalvingEpoch, OutputType};
#[derive(Debug, Clone)]
pub enum OutputFilter {
All,
To(usize),
Range(Range<usize>),
From(usize),
Size,
Epoch(HalvingEpoch),
Type(OutputType),
}
crates/brk_computer/src/states/realized.rs
-98
View File
@@ -1,98 +0,0 @@
use std::cmp::Ordering;
use brk_core::{Bitcoin, CheckedSub, Dollars};
use super::SupplyState;
#[derive(Debug, Default, Clone)]
pub struct RealizedState {
pub cap: Dollars,
pub profit: Dollars,
pub loss: Dollars,
pub value_created: Dollars,
pub adj_value_created: Dollars,
pub value_destroyed: Dollars,
pub adj_value_destroyed: Dollars,
}
impl RealizedState {
pub const NAN: Self = Self {
cap: Dollars::NAN,
profit: Dollars::NAN,
loss: Dollars::NAN,
value_created: Dollars::NAN,
adj_value_created: Dollars::NAN,
value_destroyed: Dollars::NAN,
adj_value_destroyed: Dollars::NAN,
};
pub fn reset_single_iteration_values(&mut self) {
if self.cap != Dollars::NAN {
self.profit = Dollars::ZERO;
self.loss = Dollars::ZERO;
self.value_created = Dollars::ZERO;
self.adj_value_created = Dollars::ZERO;
self.value_destroyed = Dollars::ZERO;
self.adj_value_destroyed = Dollars::ZERO;
}
}
pub fn increment(&mut self, supply_state: &SupplyState, price: Dollars) {
if supply_state.value.is_zero() {
return;
}
if self.cap == Dollars::NAN {
self.cap = Dollars::ZERO;
self.profit = Dollars::ZERO;
self.loss = Dollars::ZERO;
self.value_created = Dollars::ZERO;
self.adj_value_created = Dollars::ZERO;
self.value_destroyed = Dollars::ZERO;
self.adj_value_destroyed = Dollars::ZERO;
}
let value = price * Bitcoin::from(supply_state.value);
self.cap += value;
}
pub fn decrement(&mut self, supply_state: &SupplyState, price: Dollars) {
let value = price * Bitcoin::from(supply_state.value);
self.cap = self.cap.checked_sub(value).unwrap();
}
pub fn receive(&mut self, supply_state: &SupplyState, current_price: Dollars) {
self.increment(supply_state, current_price);
}
pub fn send(
&mut self,
supply_state: &SupplyState,
current_price: Dollars,
prev_price: Dollars,
older_than_hour: bool,
) {
let current_value = current_price * Bitcoin::from(supply_state.value);
let prev_value = prev_price * Bitcoin::from(supply_state.value);
self.value_created += current_value;
self.value_destroyed += prev_value;
if older_than_hour {
self.adj_value_created += current_value;
self.adj_value_destroyed += prev_value;
}
match current_price.cmp(&prev_price) {
Ordering::Greater => {
self.profit += current_value.checked_sub(prev_value).unwrap();
}
Ordering::Less => {
self.loss += prev_value.checked_sub(current_value).unwrap();
}
Ordering::Equal => {}
}
self.decrement(supply_state, prev_price);
}
}
crates/brk_computer/src/states/supply.rs
-41
View File
@@ -1,41 +0,0 @@
use std::ops::{Add, AddAssign, SubAssign};
use brk_core::{CheckedSub, Sats};
use serde::Serialize;
use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize)]
pub struct SupplyState {
pub utxos: usize,
pub value: Sats,
}
impl Add<SupplyState> for SupplyState {
type Output = Self;
fn add(self, rhs: SupplyState) -> Self::Output {
Self {
utxos: self.utxos + rhs.utxos,
value: self.value + rhs.value,
}
}
}
impl AddAssign<SupplyState> for SupplyState {
fn add_assign(&mut self, rhs: Self) {
*self += &rhs;
}
}
impl AddAssign<&SupplyState> for SupplyState {
fn add_assign(&mut self, rhs: &Self) {
self.utxos += rhs.utxos;
self.value += rhs.value;
}
}
impl SubAssign<&SupplyState> for SupplyState {
fn sub_assign(&mut self, rhs: &Self) {
self.utxos = self.utxos.checked_sub(rhs.utxos).unwrap();
self.value = self.value.checked_sub(rhs.value).unwrap();
}
}
crates/brk_computer/src/states/transacted.rs
-100
View File
@@ -1,100 +0,0 @@
use std::{
collections::BTreeMap,
mem,
ops::{Add, AddAssign},
};
use brk_core::{OutputType, Sats};
use super::{OutputsByType, SupplyState};
#[derive(Default)]
pub struct Transacted {
pub spendable_supply: SupplyState,
pub by_type: OutputsByType<SupplyState>,
pub by_size: BTreeMap<usize, SupplyState>,
}
impl Transacted {
#[allow(clippy::inconsistent_digit_grouping)]
pub fn iterate(&mut self, value: Sats, _type: OutputType) {
let supply = SupplyState { utxos: 1, value };
*self.by_type.get_mut(_type) += &supply;
if _type.is_unspendable() {
return;
}
self.spendable_supply += &supply;
let _value = usize::from(value);
// Need to be in sync with by_size !! but plenty fast (I think)
if _value == 0 {
*self.by_size.entry(0).or_default() += &supply;
} else if _value < 10 {
*self.by_size.entry(1).or_default() += &supply;
} else if _value < 100 {
*self.by_size.entry(10).or_default() += &supply;
} else if _value < 1_000 {
*self.by_size.entry(100).or_default() += &supply;
} else if _value < 10_000 {
*self.by_size.entry(1_000).or_default() += &supply;
} else if _value < 100_000 {
*self.by_size.entry(10_000).or_default() += &supply;
} else if _value < 1_000_000 {
*self.by_size.entry(100_000).or_default() += &supply;
} else if _value < 10_000_000 {
*self.by_size.entry(1_000_000).or_default() += &supply;
} else if _value < 1_00_000_000 {
*self.by_size.entry(10_000_000).or_default() += &supply;
} else if _value < 10_00_000_000 {
*self.by_size.entry(1_00_000_000).or_default() += &supply;
} else if _value < 100_00_000_000 {
*self.by_size.entry(10_00_000_000).or_default() += &supply;
} else if _value < 1_000_00_000_000 {
*self.by_size.entry(100_00_000_000).or_default() += &supply;
} else if _value < 10_000_00_000_000 {
*self.by_size.entry(1_000_00_000_000).or_default() += &supply;
} else if _value < 100_000_00_000_000 {
*self.by_size.entry(10_000_00_000_000).or_default() += &supply;
} else {
*self.by_size.entry(100_000_00_000_000).or_default() += &supply;
}
}
fn merge_by_size(
first: BTreeMap<usize, SupplyState>,
second: BTreeMap<usize, SupplyState>,
) -> BTreeMap<usize, SupplyState> {
let (mut source, to_consume) = if first.len() > second.len() {
(first, second)
} else {
(second, first)
};
to_consume.into_iter().for_each(|(k, v)| {
*source.entry(k).or_default() += &v;
});
source
}
}
impl Add for Transacted {
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
spendable_supply: self.spendable_supply + rhs.spendable_supply,
by_type: self.by_type + rhs.by_type,
by_size: Self::merge_by_size(self.by_size, rhs.by_size),
}
}
}
impl AddAssign for Transacted {
fn add_assign(&mut self, rhs: Self) {
self.by_size = Self::merge_by_size(mem::take(&mut self.by_size), rhs.by_size);
self.spendable_supply += &rhs.spendable_supply;
self.by_type += rhs.by_type;
}
}
crates/brk_computer/src/vecs/statefull/cohort.rs
+7 -9
View File
@@ -5,18 +5,16 @@ use brk_core::{
};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_state::{CohortState, RealizedState};
use brk_vec::{AnyCollectableVec, AnyVec, Compressed, Computation, EagerVec, VecIterator};
use crate::{
states::{CohortState, RealizedState},
vecs::{
Indexes, fetched,
grouped::{
ComputedRatioVecsFromDateIndex, ComputedValueVecsFromHeight, ComputedVecsFromHeight,
StorableVecGeneatorOptions,
},
indexes,
use crate::vecs::{
Indexes, fetched,
grouped::{
ComputedRatioVecsFromDateIndex, ComputedValueVecsFromHeight, ComputedVecsFromHeight,
StorableVecGeneatorOptions,
},
indexes,
};
const VERSION: Version = Version::ZERO;
crates/brk_computer/src/vecs/statefull/mod.rs
+3 -1
View File
@@ -8,9 +8,10 @@ use brk_vec::{
GenericStoredVec, StoredIndex, StoredVec, UnsafeSlice, VecIterator,
};
use log::info;
use outputs::OutputCohorts;
use rayon::prelude::*;
use crate::states::{
use brk_state::{
BlockState, OutputFilter, Outputs, OutputsByEpoch, OutputsByFrom, OutputsByRange,
OutputsBySize, OutputsBySpendableType, OutputsByTerm, OutputsByUpTo, SupplyState, Transacted,
};
@@ -22,6 +23,7 @@ use super::{
};
pub mod cohort;
mod outputs;
const VERSION: Version = Version::ZERO;
const BYSIZE_VERSION: Version = Version::ONE;
crates/brk_computer/src/states/outputs/mod.rs → crates/brk_computer/src/vecs/statefull/outputs.rs
+12 -98
View File
@@ -1,69 +1,20 @@
use brk_vec::StoredIndex;
use rayon::prelude::*;
use std::{collections::BTreeMap, ops::ControlFlow};
use brk_core::{CheckedSub, Dollars, HalvingEpoch, Height, Timestamp};
use brk_state::{BlockState, OutputFilter, Outputs, Transacted};
use brk_vec::StoredIndex;
use rayon::prelude::*;
mod by_epoch;
mod by_from;
mod by_range;
mod by_size;
mod by_spendable_type;
mod by_term;
mod by_type;
mod by_unspendable_type;
mod by_up_to;
// mod by_value;
mod filter;
use super::cohort;
pub use by_epoch::*;
pub use by_from::*;
pub use by_range::*;
pub use by_size::*;
pub use by_spendable_type::*;
pub use by_term::*;
pub use by_type::*;
pub use by_unspendable_type::*;
pub use by_up_to::*;
// pub use by_value::*;
pub use filter::*;
use crate::vecs;
use super::{BlockState, Transacted};
#[derive(Default, Clone)]
pub struct Outputs<T> {
pub all: T,
pub by_term: OutputsByTerm<T>,
pub by_up_to: OutputsByUpTo<T>,
pub by_from: OutputsByFrom<T>,
pub by_range: OutputsByRange<T>,
pub by_epoch: OutputsByEpoch<T>,
pub by_type: OutputsBySpendableType<T>,
pub by_size: OutputsBySize<T>,
// // Needs whole UTXO set, TODO later
// // pub by_value: OutputsByValue<T>,
pub trait OutputCohorts {
fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp);
fn send(&mut self, height_to_sent: BTreeMap<Height, Transacted>, chain_state: &[BlockState]);
fn receive(&mut self, received: Transacted, height: Height, price: Option<Dollars>);
}
impl<T> Outputs<T> {
pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
[&mut self.all]
.into_iter()
.chain(self.by_term.as_mut_vec())
.chain(self.by_up_to.as_mut_vec())
.chain(self.by_from.as_mut_vec())
.chain(self.by_range.as_mut_vec())
.chain(self.by_epoch.as_mut_vec())
.chain(self.by_size.as_mut_vec())
.chain(self.by_type.as_mut_vec())
// // .chain(self.by_value.as_mut_vec())
.collect::<Vec<_>>()
}
}
impl Outputs<(OutputFilter, vecs::statefull::cohort::Vecs)> {
pub fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp) {
impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp) {
if chain_state.is_empty() {
return;
}
@@ -117,11 +68,7 @@ impl Outputs<(OutputFilter, vecs::statefull::cohort::Vecs)> {
});
}
pub fn send(
&mut self,
height_to_sent: BTreeMap<Height, Transacted>,
chain_state: &[BlockState],
) {
fn send(&mut self, height_to_sent: BTreeMap<Height, Transacted>, chain_state: &[BlockState]) {
let mut time_based_vecs = self
.by_term
.as_mut_vec()
@@ -195,7 +142,7 @@ impl Outputs<(OutputFilter, vecs::statefull::cohort::Vecs)> {
});
}
pub fn receive(&mut self, received: Transacted, height: Height, price: Option<Dollars>) {
fn receive(&mut self, received: Transacted, height: Height, price: Option<Dollars>) {
let supply_state = received.spendable_supply;
[
@@ -233,36 +180,3 @@ impl Outputs<(OutputFilter, vecs::statefull::cohort::Vecs)> {
});
}
}
impl<T> Outputs<(OutputFilter, T)> {
pub fn vecs(&self) -> Vec<&T> {
[&self.all.1]
.into_iter()
.chain(self.by_term.vecs())
.chain(self.by_up_to.vecs())
.chain(self.by_from.vecs())
.chain(self.by_range.vecs())
.chain(self.by_epoch.vecs())
.chain(self.by_size.vecs())
// // .chain(self.by_value.vecs())
.chain(self.by_type.vecs())
.collect::<Vec<_>>()
}
}
impl<T> From<Outputs<T>> for Outputs<(OutputFilter, T)> {
fn from(value: Outputs<T>) -> Self {
Self {
all: (OutputFilter::All, value.all),
by_term: OutputsByTerm::from(value.by_term),
by_up_to: OutputsByUpTo::from(value.by_up_to),
by_from: OutputsByFrom::from(value.by_from),
by_range: OutputsByRange::from(value.by_range),
by_epoch: OutputsByEpoch::from(value.by_epoch),
by_size: OutputsBySize::from(value.by_size),
// // Needs whole UTXO set, TODO later
// // by_value: OutputsByValue<T>,
by_type: OutputsBySpendableType::from(value.by_type),
}
}
}