Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-04-25 23:29:58 -07:00
Code Issues Packages Projects Releases Wiki Activity

global: snapshot

Browse Source
This commit is contained in:
nym21
2025-06-26 16:40:29 +02:00
parent 903e69ff77
commit b7f51b03bc
45 changed files with 3237 additions and 1982 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
crates/brk_computer/src/vecs/stateful/address_cohort.rs Normal file
View File

@@ -0,0 +1,213 @@
use std::{ops::Deref, path::Path};
use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, StoredUsize, Version};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_state::{AddressCohortState, CohortStateTrait};
use brk_vec::{AnyCollectableVec, AnyIterableVec, AnyVec, Computation, EagerVec, Format};
use crate::vecs::{
Indexes, fetched, indexes, market,
stateful::{common, r#trait::CohortVecs},
};
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
starting_height: Height,
pub state: AddressCohortState,
pub height_to_address_count: EagerVec<Height, StoredUsize>,
pub inner: common::Vecs,
}
impl CohortVecs for Vecs {
#[allow(clippy::too_many_arguments)]
fn forced_import(
path: &Path,
cohort_name: Option<&str>,
computation: Computation,
format: Format,
version: Version,
fetched: Option<&fetched::Vecs>,
states_path: &Path,
compute_relative_to_all: bool,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
let suffix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{name}_{s}"));
Ok(Self {
starting_height: Height::ZERO,
state: AddressCohortState::default_and_import(
states_path,
cohort_name.unwrap_or_default(),
compute_dollars,
)?,
height_to_address_count: EagerVec::forced_import(
path,
&suffix("address_count"),
version + VERSION + Version::ZERO,
format,
)?,
inner: common::Vecs::forced_import(
path,
cohort_name,
computation,
format,
version,
fetched,
compute_relative_to_all,
)?,
})
}
fn starting_height(&self) -> Height {
[
self.state
.price_to_amount
.height()
.map_or(Height::MAX, |h| h.incremented()),
self.height_to_address_count.len().into(),
self.inner.starting_height(),
]
.into_iter()
.min()
.unwrap()
}
fn init(&mut self, starting_height: Height) {
if starting_height > self.starting_height() {
unreachable!()
}
self.starting_height = starting_height;
self.inner.init(&mut self.starting_height, &mut self.state);
}
fn validate_computed_versions(&mut self, base_version: Version) -> Result<()> {
self.height_to_address_count
.validate_computed_version_or_reset_file(
base_version + self.height_to_address_count.inner_version(),
)?;
self.inner.validate_computed_versions(base_version)
}
fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()> {
if self.starting_height > height {
return Ok(());
}
self.height_to_address_count.forced_push_at(
height,
self.state.address_count.into(),
exit,
)?;
self.inner.forced_pushed_at(height, exit, &self.state)
}
fn compute_then_force_push_unrealized_states(
&mut self,
height: Height,
height_price: Option<Dollars>,
dateindex: Option<DateIndex>,
date_price: Option<Option<Dollars>>,
exit: &Exit,
) -> Result<()> {
self.inner.compute_then_force_push_unrealized_states(
height,
height_price,
dateindex,
date_price,
exit,
&self.state,
)
}
fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
self.height_to_address_count.safe_flush(exit)?;
self.inner
.safe_flush_stateful_vecs(height, exit, &mut self.state)
}
fn compute_from_stateful(
&mut self,
starting_indexes: &Indexes,
others: &[&Self],
exit: &Exit,
) -> Result<()> {
self.height_to_address_count.compute_sum_of_others(
starting_indexes.height,
others
.iter()
.map(|v| &v.height_to_address_count)
.collect::<Vec<_>>()
.as_slice(),
exit,
)?;
self.inner.compute_from_stateful(
starting_indexes,
&others.iter().map(|v| &v.inner).collect::<Vec<_>>(),
exit,
)
}
#[allow(clippy::too_many_arguments)]
fn compute_rest_part1(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
self.inner
.compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)
}
#[allow(clippy::too_many_arguments)]
fn compute_rest_part2(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
dateindex_to_supply: &impl AnyIterableVec<DateIndex, Bitcoin>,
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()> {
self.inner.compute_rest_part2(
indexer,
indexes,
fetched,
starting_indexes,
market,
height_to_supply,
dateindex_to_supply,
height_to_realized_cap,
dateindex_to_realized_cap,
exit,
)
}
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[self.inner.vecs(), vec![&self.height_to_address_count]].concat()
}
}
impl Deref for Vecs {
type Target = common::Vecs;
fn deref(&self) -> &Self::Target {
&self.inner
}
}

279
crates/brk_computer/src/vecs/stateful/address_cohorts.rs Normal file
View File

@@ -0,0 +1,279 @@
use std::path::Path;
use brk_core::{
AddressGroups, GroupFilter, GroupedByFromSize, GroupedBySizeRange, GroupedByUpToSize, Version,
};
use brk_vec::{Computation, Format};
use crate::vecs::{
fetched,
stateful::{address_cohort, r#trait::CohortVecs},
};
const VERSION: Version = Version::new(0);
#[derive(Clone)]
pub struct Vecs(AddressGroups<(GroupFilter, address_cohort::Vecs)>);
impl Vecs {
pub fn forced_import(
path: &Path,
version: Version,
_computation: Computation,
format: Format,
fetched: Option<&fetched::Vecs>,
states_path: &Path,
) -> color_eyre::Result<Self> {
Ok(Self(
AddressGroups {
by_size_range: GroupedBySizeRange {
_0sats: address_cohort::Vecs::forced_import(
path,
Some("0sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_1sat_to_10sats: address_cohort::Vecs::forced_import(
path,
Some("from_1sat_to_10sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_10sats_to_100sats: address_cohort::Vecs::forced_import(
path,
Some("from_10sats_to_100sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_100sats_to_1_000sats: address_cohort::Vecs::forced_import(
path,
Some("from_100sats_to_1_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_1_000sats_to_10_000sats: address_cohort::Vecs::forced_import(
path,
Some("from_1_000sats_to_10_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_10_000sats_to_100_000sats: address_cohort::Vecs::forced_import(
path,
Some("from_10_000sats_to_100_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_100_000sats_to_1_000_000sats: address_cohort::Vecs::forced_import(
path,
Some("from_100_000sats_to_1_000_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_1_000_000sats_to_10_000_000sats: address_cohort::Vecs::forced_import(
path,
Some("from_1_000_000sats_to_10_000_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_10_000_000sats_to_1btc: address_cohort::Vecs::forced_import(
path,
Some("from_10_000_000sats_to_1btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_1btc_to_10btc: address_cohort::Vecs::forced_import(
path,
Some("from_1btc_to_10btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_10btc_to_100btc: address_cohort::Vecs::forced_import(
path,
Some("from_10btc_to_100btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_100btc_to_1_000btc: address_cohort::Vecs::forced_import(
path,
Some("from_100btc_to_1_000btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_1_000btc_to_10_000btc: address_cohort::Vecs::forced_import(
path,
Some("from_1_000btc_to_10_000btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_10_000btc_to_100_000btc: address_cohort::Vecs::forced_import(
path,
Some("from_10_000btc_to_100_000btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
from_100_000btc: address_cohort::Vecs::forced_import(
path,
Some("from_100_000btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
},
by_up_to_size: GroupedByUpToSize {
_1_000sats: address_cohort::Vecs::forced_import(
path,
Some("up_to_1_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
_10_000sats: address_cohort::Vecs::forced_import(
path,
Some("up_to_10_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
_1btc: address_cohort::Vecs::forced_import(
path,
Some("up_to_1btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
_10btc: address_cohort::Vecs::forced_import(
path,
Some("up_to_10btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
_100btc: address_cohort::Vecs::forced_import(
path,
Some("up_to_100btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
},
by_from_size: GroupedByFromSize {
_1_000sats: address_cohort::Vecs::forced_import(
path,
Some("from_1_000sats"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
_1btc: address_cohort::Vecs::forced_import(
path,
Some("from_1btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
_10btc: address_cohort::Vecs::forced_import(
path,
Some("from_10btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
_100btc: address_cohort::Vecs::forced_import(
path,
Some("from_100btc"),
_computation,
format,
version + VERSION + Version::ZERO,
fetched,
states_path,
true,
)?,
},
}
.into(),
))
}
}

83
crates/brk_computer/src/vecs/stateful/cohort.rs → crates/brk_computer/src/vecs/stateful/common.rs
View File

@@ -1,4 +1,3 @@
use core::panic;
use std::path::Path;
use brk_core::{
@@ -6,10 +5,9 @@ use brk_core::{
};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_state::CohortState;
use brk_state::{CohortState, CohortStateTrait};
use brk_vec::{
AnyCollectableVec, AnyIterableVec, AnyVec, Computation, EagerVec, Format, StoredIndex,
VecIterator,
AnyCollectableVec, AnyIterableVec, AnyVec, Computation, EagerVec, Format, VecIterator,
};
use crate::vecs::{
@@ -25,9 +23,6 @@ const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
starting_height: Height,
pub state: CohortState,
// Cumulative
pub height_to_realized_cap: Option<EagerVec<Height, Dollars>>,
pub height_to_supply: EagerVec<Height, Sats>,
@@ -138,7 +133,6 @@ impl Vecs {
format: Format,
version: Version,
fetched: Option<&fetched::Vecs>,
states_path: &Path,
compute_relative_to_all: bool,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
@@ -147,15 +141,7 @@ impl Vecs {
let suffix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{name}_{s}"));
let state = CohortState::default_and_import(
states_path,
cohort_name.unwrap_or_default(),
compute_dollars,
)?;
Ok(Self {
starting_height: Height::ZERO,
state,
height_to_supply_in_profit: compute_dollars.then(|| {
EagerVec::forced_import(
@@ -978,10 +964,6 @@ impl Vecs {
pub fn starting_height(&self) -> Height {
[
self.state
.price_to_amount
.height()
.map_or(usize::MAX, |h| h.incremented().unwrap_to_usize()),
self.height_to_supply.len(),
self.height_to_utxo_count.len(),
self.height_to_realized_cap
@@ -1035,25 +1017,19 @@ impl Vecs {
.unwrap()
}
pub fn init(&mut self, starting_height: Height) {
if starting_height > self.starting_height() {
unreachable!()
}
self.starting_height = starting_height;
pub fn init(&mut self, starting_height: &mut Height, state: &mut CohortState) {
if let Some(prev_height) = starting_height.decremented() {
self.state.supply.value = self
state.supply.value = self
.height_to_supply
.into_iter()
.unwrap_get_inner(prev_height);
self.state.supply.utxos = *self
state.supply.utxos = *self
.height_to_utxo_count
.into_iter()
.unwrap_get_inner(prev_height);
if let Some(height_to_realized_cap) = self.height_to_realized_cap.as_mut() {
self.state.realized.as_mut().unwrap().cap = height_to_realized_cap
state.realized.as_mut().unwrap().cap = height_to_realized_cap
.into_iter()
.unwrap_get_inner(prev_height);
}
@@ -1286,35 +1262,33 @@ impl Vecs {
Ok(())
}
pub fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()> {
if self.starting_height > height {
return Ok(());
}
pub fn forced_pushed_at(
&mut self,
height: Height,
exit: &Exit,
state: &CohortState,
) -> Result<()> {
self.height_to_supply
.forced_push_at(height, self.state.supply.value, exit)?;
.forced_push_at(height, state.supply.value, exit)?;
self.height_to_utxo_count.forced_push_at(
height,
StoredUsize::from(self.state.supply.utxos),
StoredUsize::from(state.supply.utxos),
exit,
)?;
self.height_to_satblocks_destroyed.forced_push_at(
height,
self.state.satblocks_destroyed,
state.satblocks_destroyed,
exit,
)?;
self.height_to_satdays_destroyed.forced_push_at(
height,
self.state.satdays_destroyed,
exit,
)?;
self.height_to_satdays_destroyed
.forced_push_at(height, state.satdays_destroyed, exit)?;
if let Some(height_to_realized_cap) = self.height_to_realized_cap.as_mut() {
let realized = self.state.realized.as_ref().unwrap_or_else(|| {
dbg!((&self.state.realized, &self.state.supply));
let realized = state.realized.as_ref().unwrap_or_else(|| {
dbg!((&state.realized, &state.supply));
panic!();
});
@@ -1355,6 +1329,7 @@ impl Vecs {
dateindex: Option<DateIndex>,
date_price: Option<Option<Dollars>>,
exit: &Exit,
state: &CohortState,
) -> Result<()> {
if let Some(height_price) = height_price {
self.height_to_min_price_paid
@@ -1362,7 +1337,7 @@ impl Vecs {
.unwrap()
.forced_push_at(
height,
self.state
state
.price_to_amount
.first_key_value()
.map(|(&dollars, _)| dollars)
@@ -1374,7 +1349,7 @@ impl Vecs {
.unwrap()
.forced_push_at(
height,
self.state
state
.price_to_amount
.last_key_value()
.map(|(&dollars, _)| dollars)
@@ -1382,9 +1357,8 @@ impl Vecs {
exit,
)?;
let (height_unrealized_state, date_unrealized_state) = self
.state
.compute_unrealized_states(height_price, date_price.unwrap());
let (height_unrealized_state, date_unrealized_state) =
state.compute_unrealized_states(height_price, date_price.unwrap());
self.height_to_supply_even
.as_mut()
@@ -1436,7 +1410,12 @@ impl Vecs {
Ok(())
}
pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
pub fn safe_flush_stateful_vecs(
&mut self,
height: Height,
exit: &Exit,
state: &mut CohortState,
) -> Result<()> {
self.height_to_supply.safe_flush(exit)?;
self.height_to_utxo_count.safe_flush(exit)?;
self.height_to_satdays_destroyed.safe_flush(exit)?;
@@ -1518,7 +1497,7 @@ impl Vecs {
.safe_flush(exit)?;
}
self.state.commit(height)?;
state.commit(height)?;
Ok(())
}

1193
crates/brk_computer/src/vecs/stateful/mod.rs
View File

File diff suppressed because it is too large Load Diff

24
crates/brk_computer/src/vecs/stateful/outputs.rs
View File

@@ -1,14 +1,14 @@
use std::{collections::BTreeMap, ops::ControlFlow};
use brk_core::{CheckedSub, Dollars, HalvingEpoch, Height, Result, Timestamp};
use brk_core::{
CheckedSub, Dollars, GroupFilter, HalvingEpoch, Height, Result, Timestamp, UTXOGroups,
};
use brk_exit::Exit;
use brk_state::{BlockState, OutputFilter, Outputs, Transacted};
use brk_state::{BlockState, CohortStateTrait, Transacted};
use brk_vec::StoredIndex;
use rayon::prelude::*;
use crate::vecs::Indexes;
use super::cohort;
use crate::vecs::{Indexes, stateful::utxo_cohort};
pub trait OutputCohorts {
fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp);
@@ -17,7 +17,7 @@ pub trait OutputCohorts {
fn compute_overlapping_vecs(&mut self, starting_indexes: &Indexes, exit: &Exit) -> Result<()>;
}
impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
impl OutputCohorts for UTXOGroups<(GroupFilter, utxo_cohort::Vecs)> {
fn tick_tock_next_block(&mut self, chain_state: &[BlockState], timestamp: Timestamp) {
if chain_state.is_empty() {
return;
@@ -92,10 +92,10 @@ impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
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),
GroupFilter::From(from) => *from <= days_old,
GroupFilter::To(to) => *to > days_old,
GroupFilter::Range(range) => range.contains(&days_old),
GroupFilter::Epoch(epoch) => *epoch == HalvingEpoch::from(height),
_ => unreachable!(),
})
.for_each(|(_, vecs)| {
@@ -123,6 +123,7 @@ impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
);
sent.by_size_group
.as_typed_vec()
.into_iter()
.for_each(|(group, supply_state)| {
self.by_size_range.get_mut(group).1.state.send(
@@ -154,7 +155,7 @@ impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
.into_iter()
.for_each(|(filter, vecs)| {
let output_type = match filter {
OutputFilter::Type(output_type) => *output_type,
GroupFilter::Type(output_type) => *output_type,
_ => unreachable!(),
};
vecs.state.receive(received.by_type.get(output_type), price)
@@ -162,6 +163,7 @@ impl OutputCohorts for Outputs<(OutputFilter, cohort::Vecs)> {
received
.by_size_group
.as_typed_vec()
.into_iter()
.for_each(|(group, supply_state)| {
self.by_size_range

75
crates/brk_computer/src/vecs/stateful/trait.rs Normal file
View File

@@ -0,0 +1,75 @@
use std::path::Path;
use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, Version};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, Format};
use crate::vecs::{Indexes, fetched, indexes, market};
pub trait CohortVecs: Sized {
#[allow(clippy::too_many_arguments)]
fn forced_import(
path: &Path,
cohort_name: Option<&str>,
computation: Computation,
format: Format,
version: Version,
fetched: Option<&fetched::Vecs>,
states_path: &Path,
compute_relative_to_all: bool,
) -> color_eyre::Result<Self>;
fn starting_height(&self) -> Height;
fn init(&mut self, starting_height: Height);
fn validate_computed_versions(&mut self, base_version: Version) -> Result<()>;
fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()>;
fn compute_then_force_push_unrealized_states(
&mut self,
height: Height,
height_price: Option<Dollars>,
dateindex: Option<DateIndex>,
date_price: Option<Option<Dollars>>,
exit: &Exit,
) -> Result<()>;
fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()>;
fn compute_from_stateful(
&mut self,
starting_indexes: &Indexes,
others: &[&Self],
exit: &Exit,
) -> Result<()>;
#[allow(clippy::too_many_arguments)]
fn compute_rest_part1(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()>;
#[allow(clippy::too_many_arguments)]
fn compute_rest_part2(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
dateindex_to_supply: &impl AnyIterableVec<DateIndex, Bitcoin>,
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()>;
fn vecs(&self) -> Vec<&dyn AnyCollectableVec>;
}

180
crates/brk_computer/src/vecs/stateful/utxo_cohort.rs Normal file
View File

@@ -0,0 +1,180 @@
use std::{ops::Deref, path::Path};
use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, Version};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_state::{CohortStateTrait, UTXOCohortState};
use brk_vec::{AnyCollectableVec, AnyIterableVec, Computation, Format};
use crate::vecs::{
Indexes, fetched, indexes, market,
stateful::{common, r#trait::CohortVecs},
};
#[derive(Clone)]
pub struct Vecs {
starting_height: Height,
pub state: UTXOCohortState,
inner: common::Vecs,
}
impl CohortVecs for Vecs {
#[allow(clippy::too_many_arguments)]
fn forced_import(
path: &Path,
cohort_name: Option<&str>,
computation: Computation,
format: Format,
version: Version,
fetched: Option<&fetched::Vecs>,
states_path: &Path,
compute_relative_to_all: bool,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
Ok(Self {
starting_height: Height::ZERO,
state: UTXOCohortState::default_and_import(
states_path,
cohort_name.unwrap_or_default(),
compute_dollars,
)?,
inner: common::Vecs::forced_import(
path,
cohort_name,
computation,
format,
version,
fetched,
compute_relative_to_all,
)?,
})
}
fn starting_height(&self) -> Height {
[
self.state
.price_to_amount
.height()
.map_or(Height::MAX, |h| h.incremented()),
self.inner.starting_height(),
]
.into_iter()
.min()
.unwrap()
}
fn init(&mut self, starting_height: Height) {
if starting_height > self.starting_height() {
unreachable!()
}
self.starting_height = starting_height;
self.inner.init(&mut self.starting_height, &mut self.state);
}
fn validate_computed_versions(&mut self, base_version: Version) -> Result<()> {
self.inner.validate_computed_versions(base_version)
}
fn forced_pushed_at(&mut self, height: Height, exit: &Exit) -> Result<()> {
if self.starting_height > height {
return Ok(());
}
self.inner.forced_pushed_at(height, exit, &self.state)
}
fn compute_then_force_push_unrealized_states(
&mut self,
height: Height,
height_price: Option<Dollars>,
dateindex: Option<DateIndex>,
date_price: Option<Option<Dollars>>,
exit: &Exit,
) -> Result<()> {
self.inner.compute_then_force_push_unrealized_states(
height,
height_price,
dateindex,
date_price,
exit,
&self.state,
)
}
fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
self.inner
.safe_flush_stateful_vecs(height, exit, &mut self.state)
}
fn compute_from_stateful(
&mut self,
starting_indexes: &Indexes,
others: &[&Self],
exit: &Exit,
) -> Result<()> {
self.inner.compute_from_stateful(
starting_indexes,
&others.iter().map(|v| &v.inner).collect::<Vec<_>>(),
exit,
)
}
#[allow(clippy::too_many_arguments)]
fn compute_rest_part1(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
self.inner
.compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)
}
#[allow(clippy::too_many_arguments)]
fn compute_rest_part2(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
dateindex_to_supply: &impl AnyIterableVec<DateIndex, Bitcoin>,
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()> {
self.inner.compute_rest_part2(
indexer,
indexes,
fetched,
starting_indexes,
market,
height_to_supply,
dateindex_to_supply,
height_to_realized_cap,
dateindex_to_realized_cap,
exit,
)
}
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
self.inner.vecs()
}
}
impl Deref for Vecs {
type Target = common::Vecs;
fn deref(&self) -> &Self::Target {
&self.inner
}
}

1292
crates/brk_computer/src/vecs/stateful/utxo_cohorts.rs Normal file
View File

File diff suppressed because it is too large Load Diff