Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-07-24 17:38:09 -07:00
Code Issues Packages Projects Releases Wiki Activity

global: utxos part 5

Browse Source
This commit is contained in:
nym21
2025-05-22 19:04:55 +02:00
parent 5893376279
commit e002a61a19
38 changed files with 3047 additions and 1623 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_computer/src/states/block.rs
+44 -20
View File
@@ -1,40 +1,64 @@
#![allow(unused)]
use std::ops::{Add, AddAssign, SubAssign};
use std::{
iter::Sum,
ops::{Add, AddAssign, SubAssign},
};
use brk_core::{Dollars, Sats, Timestamp};
use brk_core::{CheckedSub, Sats, StoredU32};
use serde::Serialize;
use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
use super::{OutputsByType, SupplyState};
#[derive(Debug, Default, Clone, FromBytes, Immutable, IntoBytes, KnownLayout, Serialize)]
#[derive(Debug, Clone)]
pub struct BlockState {
pub utxos: usize,
pub value: Sats,
pub supply: SupplyState,
pub price: Option<Dollars>,
pub timestamp: Timestamp,
}
impl Add<BlockState> for BlockState {
type Output = Self;
fn add(self, rhs: BlockState) -> Self::Output {
Self {
utxos: self.utxos + rhs.utxos,
value: self.value + rhs.value,
}
fn add(mut self, rhs: BlockState) -> Self::Output {
self.supply += &rhs.supply;
self
}
}
impl AddAssign<&BlockState> for BlockState {
fn add_assign(&mut self, rhs: &BlockState) {
self.utxos += rhs.utxos;
self.value += rhs.value;
self.supply += &rhs.supply;
}
}
impl SubAssign for BlockState {
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();
self.supply -= rhs.supply;
}
}
pub struct ReceivedBlockStateData<'a> {
pub received: &'a OutputsByType<(SupplyState, Vec<Sats>)>,
pub timestamp: Timestamp,
pub price: Option<Dollars>,
}
impl<'a> From<ReceivedBlockStateData<'a>> for BlockState {
fn from(
ReceivedBlockStateData {
received,
timestamp,
price,
}: ReceivedBlockStateData<'a>,
) -> Self {
let mut block_state = BlockState {
supply: SupplyState::default(),
price,
timestamp,
};
received
.spendable
.as_vec()
.into_iter()
.for_each(|spendable_block_state| {
block_state.supply += &spendable_block_state.0;
});
block_state.supply.value += received.unspendable.unknown.0.value;
block_state.supply.utxos +=
received.unspendable.empty.0.utxos + received.unspendable.unknown.0.utxos;
block_state
}
}
crates/brk_computer/src/states/cohort.rs
+20 -146
View File
@@ -1,155 +1,29 @@
#![allow(unused)]
use brk_core::{Bitcoin, CheckedSub, Dollars};
use brk_core::{Dollars, Sats, StoredUsize};
use super::SupplyState;
// Vecs ? probably
#[derive(Default, Clone)]
pub struct CohortState {
pub realized_cap: Dollars,
pub supply: Sats,
pub utxo_count: StoredUsize,
pub supply: SupplyState,
pub realized_cap: Option<Dollars>,
// pub price_to_amount: PriceToValue<Amount>, save it not rounded in fjall
}
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,
impl CohortState {
pub fn increment(&mut self, supply_state: &SupplyState, price: Option<Dollars>) {
self.supply += supply_state;
if let Some(realized_cap) = self.realized_cap.as_mut() {
*realized_cap += price.unwrap() * Bitcoin::from(supply_state.value);
}
}
pub fn decrement(&mut self, supply_state: SupplyState, price: Option<Dollars>) {
if let Some(realized_cap) = self.realized_cap.as_mut() {
*realized_cap = realized_cap
.checked_sub(price.unwrap() * Bitcoin::from(supply_state.value))
.unwrap();
}
self.supply -= supply_state;
}
}
crates/brk_computer/src/states/hot.rs
+142
View File
@@ -0,0 +1,142 @@
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
+6 -6
View File
@@ -1,13 +1,13 @@
mod block;
mod cohort;
mod outputs;
mod realized;
mod received;
mod sent;
// mod realized;
// mod hot;
mod supply;
pub use block::*;
pub use cohort::*;
pub use outputs::*;
pub use realized::*;
pub use received::*;
pub use sent::*;
// pub use realized::*;
// pub use hot::*;
pub use supply::*;
crates/brk_computer/src/states/outputs/by_epoch.rs
+43 -4
View File
@@ -1,20 +1,59 @@
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,
pub _5: 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 mut_flatten(&mut self) -> Vec<&mut T> {
vec![
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,
&mut self._5,
]
}
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
+80 -2
View File
@@ -1,20 +1,98 @@
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 mut_flatten(&mut self) -> Vec<&mut T> {
vec![
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
+46 -4
View File
@@ -1,3 +1,5 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByRange<T> {
pub _1d_to_1w: T,
@@ -7,15 +9,35 @@ pub struct OutputsByRange<T> {
pub _6m_to_1y: T,
pub _1y_to_2y: T,
pub _2y_to_3y: T,
pub _3y_to_5y: 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 mut_flatten(&mut self) -> Vec<&mut T> {
vec![
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,
@@ -23,10 +45,30 @@ impl<T> OutputsByRange<T> {
&mut self._6m_to_1y,
&mut self._1y_to_2y,
&mut self._2y_to_3y,
&mut self._3y_to_5y,
&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
+91 -2
View File
@@ -1,3 +1,7 @@
use brk_core::Sats;
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsBySize<T> {
pub from_1sat_to_10sats: T,
@@ -16,9 +20,73 @@ pub struct OutputsBySize<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 {
from_1sat_to_10sats: (
OutputFilter::Size(Sats::new(1)..Sats::new(10)),
value.from_1sat_to_10sats,
),
from_10sats_to_100sats: (
OutputFilter::Size(Sats::new(10)..Sats::new(100)),
value.from_10sats_to_100sats,
),
from_100sats_to_1_000sats: (
OutputFilter::Size(Sats::new(100)..Sats::new(1_000)),
value.from_100sats_to_1_000sats,
),
from_1_000sats_to_10_000sats: (
OutputFilter::Size(Sats::new(1_000)..Sats::new(10_000)),
value.from_1_000sats_to_10_000sats,
),
from_10_000sats_to_100_000sats: (
OutputFilter::Size(Sats::new(10_000)..Sats::new(100_000)),
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)),
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)),
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)),
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)),
value.from_1btc_to_10btc,
),
from_10btc_to_100btc: (
OutputFilter::Size(Sats::new(10_00_000_000)..Sats::new(100_00_000_000)),
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)),
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)),
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)),
value.from_10_000btc_to_100_000btc,
),
from_100_000btc: (
OutputFilter::Size(Sats::new(100_000_00_000_000)..Sats::MAX),
value.from_100_000btc,
),
}
}
}
impl<T> OutputsBySize<T> {
pub fn mut_flatten(&mut self) -> Vec<&mut T> {
vec![
pub fn as_mut_vec(&mut self) -> [&mut T; 14] {
[
&mut self.from_1sat_to_10sats,
&mut self.from_10sats_to_100sats,
&mut self.from_100sats_to_1_000sats,
@@ -36,3 +104,24 @@ impl<T> OutputsBySize<T> {
]
}
}
impl<T> OutputsBySize<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 14] {
[
&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
+134
View File
@@ -0,0 +1,134 @@
use brk_core::{OutputType, Sats};
use crate::states::SupplyState;
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,
}
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,
_ => 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,
_ => unreachable!(),
}
}
pub fn as_vec(&self) -> [&T; 9] {
[
&self.p2pk65,
&self.p2pk33,
&self.p2pkh,
&self.p2ms,
&self.p2sh,
&self.p2wpkh,
&self.p2wsh,
&self.p2tr,
&self.p2a,
]
}
pub fn as_mut_vec(&mut self) -> [&mut T; 9] {
[
&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,
]
}
pub fn as_typed_vec(&self) -> [(OutputType, &T); 9] {
[
(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),
]
}
}
impl<T> OutputsBySpendableType<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 9] {
[
&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,
]
}
}
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),
}
}
}
impl OutputsBySpendableType<(SupplyState, Vec<Sats>)> {
pub fn reduce(&self) -> SupplyState {
let mut supply_state = SupplyState::default();
self.as_vec().iter().for_each(|(supply_state_, _)| {
supply_state += supply_state_;
});
supply_state
}
}
crates/brk_computer/src/states/outputs/by_term.rs
+19 -2
View File
@@ -1,3 +1,5 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByTerm<T> {
pub short: T,
@@ -5,7 +7,22 @@ pub struct OutputsByTerm<T> {
}
impl<T> OutputsByTerm<T> {
pub fn mut_flatten(&mut self) -> Vec<&mut T> {
vec![&mut self.short, &mut self.long]
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
+43 -76
View File
@@ -1,94 +1,61 @@
use brk_core::OutputType;
use super::{OutputsBySpendableType, OutputsByUnspendableType};
#[derive(Default, Clone)]
pub struct OutputsByType<T> {
pub p2pk65: T,
pub p2pk33: T,
pub p2pkh: T,
pub p2ms: T,
pub p2sh: T,
pub op_return: T,
pub p2wpkh: T,
pub p2wsh: T,
pub p2tr: T,
pub p2a: T,
pub empty: T,
pub unknown: 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.p2pk65,
OutputType::P2PK33 => &self.p2pk33,
OutputType::P2PKH => &self.p2pkh,
OutputType::P2MS => &self.p2ms,
OutputType::P2SH => &self.p2sh,
OutputType::OpReturn => &self.op_return,
OutputType::P2WPKH => &self.p2wpkh,
OutputType::P2WSH => &self.p2wsh,
OutputType::P2TR => &self.p2tr,
OutputType::P2A => &self.p2a,
OutputType::Empty => &self.empty,
OutputType::Unknown => &self.unknown,
}
}
// 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::OpReturn => &self.unspendable.op_return,
// OutputType::Empty => &self.unspendable.empty,
// OutputType::Unknown => &self.unspendable.unknown,
// }
// }
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::OpReturn => &mut self.op_return,
OutputType::P2WPKH => &mut self.p2wpkh,
OutputType::P2WSH => &mut self.p2wsh,
OutputType::P2TR => &mut self.p2tr,
OutputType::P2A => &mut self.p2a,
OutputType::Empty => &mut self.empty,
OutputType::Unknown => &mut self.unknown,
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::OpReturn => &mut self.unspendable.op_return,
OutputType::Empty => &mut self.unspendable.empty,
OutputType::Unknown => &mut self.unspendable.unknown,
}
}
pub fn to_spendable_vec(&self) -> Vec<&T> {
OutputType::as_vec()
pub fn as_vec(&self) -> Vec<&T> {
self.spendable
.as_vec()
.into_iter()
.map(|t| (self.get(t)))
.chain(self.unspendable.as_vec())
.collect::<Vec<_>>()
}
pub fn as_vec(&mut self) -> Vec<&T> {
vec![
&self.p2pk65,
&self.p2pk33,
&self.p2pkh,
&self.p2ms,
&self.p2sh,
&self.op_return,
&self.p2wpkh,
&self.p2wsh,
&self.p2tr,
&self.p2a,
&self.empty,
&self.unknown,
]
}
pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
vec![
&mut self.p2pk65,
&mut self.p2pk33,
&mut self.p2pkh,
&mut self.p2ms,
&mut self.p2sh,
&mut self.op_return,
&mut self.p2wpkh,
&mut self.p2wsh,
&mut self.p2tr,
&mut self.p2a,
&mut self.empty,
&mut self.unknown,
]
}
// 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<_>>()
// }
}
crates/brk_computer/src/states/outputs/by_unspendable_type.rs
+43
View File
@@ -0,0 +1,43 @@
// use brk_core::OutputType;
#[derive(Default, Clone)]
pub struct OutputsByUnspendableType<T> {
pub op_return: T,
pub empty: T,
pub unknown: T,
}
impl<T> OutputsByUnspendableType<T> {
// pub fn get(&self, output_type: OutputType) -> &T {
// match output_type {
// OutputType::OpReturn => &self.op_return,
// OutputType::Empty => &self.empty,
// OutputType::Unknown => &self.unknown,
// _ => unreachable!(),
// }
// }
// pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
// match output_type {
// OutputType::OpReturn => &mut self.op_return,
// OutputType::Empty => &mut self.empty,
// OutputType::Unknown => &mut self.unknown,
// _ => unreachable!(),
// }
// }
// pub fn to_unspendable_vec(&self) -> Vec<&T> {
// OutputType::as_vec()
// .into_iter()
// .map(|t| (self.get(t)))
// .collect::<Vec<_>>()
// }
pub fn as_vec(&self) -> [&T; 3] {
[&self.op_return, &self.empty, &self.unknown]
}
// pub fn as_mut_vec(&mut self) -> [&mut T; 3] {
// [&mut self.op_return, &mut self.empty, &mut self.unknown]
// }
}
crates/brk_computer/src/states/outputs/by_up_to.rs
+60 -2
View File
@@ -1,3 +1,5 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByUpTo<T> {
pub _1d: T,
@@ -11,15 +13,18 @@ pub struct OutputsByUpTo<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 mut_flatten(&mut self) -> Vec<&mut T> {
vec![
pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
[
&mut self._1d,
&mut self._1w,
&mut self._1m,
@@ -31,10 +36,63 @@ impl<T> OutputsByUpTo<T> {
&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
+1 -1
View File
@@ -17,7 +17,7 @@ pub struct OutputsByValue<T> {
}
impl<T> OutputsByValue<T> {
pub fn mut_flatten(&mut self) -> Vec<&mut T> {
pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
vec![
&mut self.up_to_1cent,
&mut self.from_1c_to_10c,
crates/brk_computer/src/states/outputs/filter.rs
+14
View File
@@ -0,0 +1,14 @@
use std::ops::Range;
use brk_core::{HalvingEpoch, OutputType, Sats};
#[derive(Clone)]
pub enum OutputFilter {
All,
To(usize),
Range(Range<usize>),
From(usize),
Size(Range<Sats>),
Epoch(HalvingEpoch),
Type(OutputType),
}
crates/brk_computer/src/states/outputs/mod.rs
+259 -16
View File
@@ -1,45 +1,288 @@
#![allow(unused)]
use brk_vec::StoredIndex;
use rayon::prelude::*;
use std::{collections::BTreeMap, ops::ControlFlow};
use brk_core::OutputType;
use crate::vecs::utxos::Vecs_;
use brk_core::{Dollars, HalvingEpoch, Height, Sats, Timestamp};
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 by_value;
mod filter;
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 by_value::*;
pub use filter::*;
use crate::vecs;
use super::{BlockState, SupplyState};
#[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_size: OutputsBySize<T>,
pub by_value: OutputsByValue<T>,
pub by_type: OutputsByType<T>,
// pub by_up_to: OutputsByUpTo<T>,
// pub by_from: OutputsByFrom<T>,
// pub by_range: OutputsByRange<T>,
// pub by_epoch: OutputsByEpoch<T>,
// pub by_size: OutputsBySize<T>,
// // Needs whole UTXO set, TODO later
// // pub by_value: OutputsByValue<T>,
// pub by_spendable_type: OutputsBySpendableType<T>,
}
impl<T> Outputs<T> {
pub fn mut_flatten(&mut self) -> Vec<&mut T> {
[vec![&mut self.all], self.by_term.mut_flatten()]
pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
[&mut self.all]
.into_iter()
.flatten()
.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_value.as_mut_vec())
// .chain(self.by_spendable_type.as_mut_vec())
.collect::<Vec<_>>()
}
}
impl Outputs<(OutputFilter, vecs::utxos::cohort::Vecs)> {
pub fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp) {
if chain_state.is_empty() {
return;
}
let prev_timestamp = chain_state.last().unwrap().timestamp;
self.by_term
.as_mut_vec()
.into_par_iter()
// .chain(self.by_up_to.as_mut_vec())
// .chain(self.by_from.as_mut_vec())
// .chain(self.by_range.as_mut_vec())
.for_each(|(filter, v)| {
let state = &mut v.state;
let mut check_days_old = |days_old: usize| -> bool {
match filter {
OutputFilter::From(from) => *from <= days_old,
OutputFilter::To(to) => *to > days_old,
OutputFilter::Range(range) => range.contains(&days_old),
OutputFilter::All
| OutputFilter::Epoch(_)
| OutputFilter::Size(_)
| OutputFilter::Type(_) => unreachable!(),
}
};
let _ = chain_state
.iter()
.try_for_each(|block_state| -> ControlFlow<()> {
let prev_days_old = block_state
.timestamp
.difference_in_days_between(prev_timestamp);
let days_old = block_state.timestamp.difference_in_days_between(timestamp);
if prev_days_old == days_old {
return ControlFlow::Continue(());
}
let is = check_days_old(days_old);
let was = check_days_old(prev_days_old);
if is && !was {
state.increment(&block_state.supply, block_state.price);
} else if was && !is {
state.decrement(block_state.supply.clone(), block_state.price);
}
ControlFlow::Continue(())
});
});
}
pub fn send(
&mut self,
height_to_sent: BTreeMap<Height, OutputsByType<(SupplyState, Vec<Sats>)>>,
chain_state: &[BlockState],
) {
let mut time_based_vecs = self
.by_term
.as_mut_vec()
.into_iter()
// .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())
.collect::<Vec<_>>();
let last_timestamp = chain_state.last().unwrap().timestamp;
height_to_sent.into_iter().for_each(|(height, by_type)| {
let by_spendable_type = by_type.spendable;
let block_state = chain_state.get(height.unwrap_to_usize()).unwrap();
let price = block_state.price;
let supply_state = by_spendable_type.reduce();
let days_old = block_state
.timestamp
.difference_in_days_between(last_timestamp);
self.all.1.state.decrement(supply_state.clone(), price);
// by_spendable_type.as_typed_vec().into_iter().for_each(
// |(output_type, (supply_state, _))| {
// self.by_spendable_type
// .get_mut(output_type)
// .1
// .state
// .decrement(supply_state.clone(), price)
// },
// );
// by_spendable_type
// .as_vec()
// .into_iter()
// .flat_map(|(_, sats_received)| sats_received.iter())
// .for_each(|sats| {
// let sats = *sats;
// self.by_size
// .as_mut_vec()
// .iter_mut()
// .filter(|(filter, _)| match filter {
// OutputFilter::Size(range) => range.contains(&sats),
// _ => unreachable!(),
// })
// .for_each(|(_, vec)| {
// vec.state.decrement(
// SupplyState {
// utxos: 1,
// value: sats,
// },
// price,
// );
// });
// });
time_based_vecs
.iter_mut()
.filter(|(filter, _)| match filter {
OutputFilter::From(from) => *from <= days_old,
OutputFilter::To(to) => *to > days_old,
OutputFilter::Range(range) => range.contains(&days_old),
OutputFilter::Epoch(epoch) => *epoch == HalvingEpoch::from(height),
_ => unreachable!(),
})
.for_each(|(_, vecs)| {
vecs.state.decrement(supply_state.clone(), price);
});
});
}
pub fn receive(
&mut self,
received: OutputsByType<(SupplyState, Vec<Sats>)>,
height: Height,
price: Option<Dollars>,
) {
let supply_state = received.spendable.reduce();
[
&mut self.all.1,
&mut self.by_term.short.1,
// &mut self.by_epoch.mut_vec_from_height(height).1,
// Skip from and range as can't receive in the past
]
.into_iter()
// .chain(self.by_up_to.as_mut_vec().map(|(_, v)| v))
.for_each(|v| {
v.state.increment(&supply_state, price);
});
// let mut by_size = self.by_size.as_mut_vec();
// received
// .spendable
// .as_vec()
// .into_iter()
// .flat_map(|(_, sats_received)| sats_received.iter())
// .for_each(|sats| {
// let sats = *sats;
// by_size
// .iter_mut()
// .filter(|(filter, _)| match filter {
// OutputFilter::Size(range) => range.contains(&sats),
// _ => unreachable!(),
// })
// .for_each(|(_, vec)| {
// vec.state.increment(
// &SupplyState {
// utxos: 1,
// value: sats,
// },
// price,
// );
// });
// });
// self.by_spendable_type
// .as_mut_vec()
// .into_iter()
// .for_each(|(filter, vecs)| {
// let output_type = match filter {
// OutputFilter::Type(output_type) => *output_type,
// _ => unreachable!(),
// };
// vecs.state
// .increment(&received.spendable.get(output_type).0, price)
// });
}
}
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_spendable_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_spendable_type: OutputsBySpendableType::from(value.by_spendable_type),
}
}
}
crates/brk_computer/src/states/received.rs
-8
View File
@@ -1,8 +0,0 @@
use brk_core::{Sats, StoredUsize};
#[derive(Debug, Default)]
pub struct ReceivedState {
utxos: StoredUsize,
sats: Sats,
unspendable: Sats,
}
crates/brk_computer/src/states/sent.rs
-7
View File
@@ -1,7 +0,0 @@
use brk_core::{Sats, StoredUsize};
#[derive(Debug, Default)]
pub struct SentState {
utxos: StoredUsize,
sats: Sats,
}
crates/brk_computer/src/states/supply.rs
+35
View File
@@ -0,0 +1,35 @@
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.utxos += rhs.utxos;
self.value += rhs.value;
}
}
impl SubAssign 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();
}
}