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

global: one big snapshot

Browse Source
This commit is contained in:
nym21
2025-08-02 16:59:22 +02:00
parent aa8b47a3dd
commit f7aa9424db
252 changed files with 6283 additions and 5264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
crates/brk_computer/src/all.rs
View File

@@ -1,13 +1,13 @@
use std::{path::Path, sync::Arc};
use brk_core::Version;
use brk_exit::Exit;
use brk_error::Result;
use brk_fetcher::Fetcher;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, Computation, File, Format};
use brk_structs::Version;
use brk_vecs::{AnyCollectableVec, Computation, Exit, File, Format};
use log::info;
use crate::{blocks, cointime, constants, fetched, indexes, market, mining, transactions};
use crate::{blocks, cointime, constants, fetched, indexes, market, mining, price, transactions};
use super::stateful;
@@ -20,6 +20,7 @@ pub struct Vecs {
pub blocks: blocks::Vecs,
pub mining: mining::Vecs,
pub market: market::Vecs,
pub price: Option<price::Vecs>,
pub transactions: transactions::Vecs,
pub stateful: stateful::Vecs,
pub fetched: Option<fetched::Vecs>,
@@ -32,12 +33,12 @@ impl Vecs {
file: &Arc<File>,
version: Version,
indexer: &Indexer,
fetch: bool,
fetcher: Option<Fetcher>,
computation: Computation,
format: Format,
fetched_file: &Arc<File>,
states_path: &Path,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let indexes = indexes::Vecs::forced_import(
file,
version + VERSION + Version::ZERO,
@@ -46,10 +47,19 @@ impl Vecs {
format,
)?;
let fetched = fetch.then(|| {
let fetched = fetcher.map(|fetcher| {
fetched::Vecs::forced_import(
file,
fetched_file,
fetcher,
version + VERSION + Version::ZERO,
)
.unwrap()
});
let price = fetched.is_some().then(|| {
price::Vecs::forced_import(
file,
version + VERSION + Version::ZERO,
computation,
format,
@@ -93,7 +103,7 @@ impl Vecs {
computation,
format,
&indexes,
fetched.as_ref(),
price.as_ref(),
states_path,
)?,
transactions: transactions::Vecs::forced_import(
@@ -103,7 +113,7 @@ impl Vecs {
&indexes,
computation,
format,
fetched.as_ref(),
price.as_ref(),
)?,
cointime: cointime::Vecs::forced_import(
file,
@@ -111,10 +121,11 @@ impl Vecs {
computation,
format,
&indexes,
fetched.as_ref(),
price.as_ref(),
)?,
indexes,
fetched,
price,
})
}
@@ -122,9 +133,8 @@ impl Vecs {
&mut self,
indexer: &Indexer,
starting_indexes: brk_indexer::Indexes,
fetcher: Option<&mut Fetcher>,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
info!("Computing indexes...");
let mut starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
@@ -142,11 +152,13 @@ impl Vecs {
if let Some(fetched) = self.fetched.as_mut() {
info!("Computing fetched...");
fetched.compute(
fetched.compute(indexer, &self.indexes, &starting_indexes, exit)?;
self.price.as_mut().unwrap().compute(
indexer,
&self.indexes,
&starting_indexes,
fetcher.unwrap(),
fetched,
exit,
)?;
}
@@ -156,16 +168,16 @@ impl Vecs {
indexer,
&self.indexes,
&starting_indexes,
self.fetched.as_ref(),
self.price.as_ref(),
exit,
)?;
if let Some(fetched) = self.fetched.as_ref() {
if let Some(price) = self.price.as_ref() {
info!("Computing market...");
self.market.compute(
indexer,
&self.indexes,
fetched,
price,
&mut self.transactions,
&starting_indexes,
exit,
@@ -177,7 +189,7 @@ impl Vecs {
indexer,
&self.indexes,
&self.transactions,
self.fetched.as_ref(),
self.price.as_ref(),
&self.market,
&mut starting_indexes,
exit,
@@ -187,7 +199,7 @@ impl Vecs {
indexer,
&self.indexes,
&starting_indexes,
self.fetched.as_ref(),
self.price.as_ref(),
&self.transactions,
&self.stateful,
exit,
@@ -207,6 +219,7 @@ impl Vecs {
self.stateful.vecs(),
self.cointime.vecs(),
self.fetched.as_ref().map_or(vec![], |v| v.vecs()),
self.price.as_ref().map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()

56
crates/brk_computer/src/blocks.rs
View File

@@ -1,12 +1,12 @@
use std::sync::Arc;
use std::{path::Path, sync::Arc};
use brk_core::{
CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, StoredUsize,
Timestamp, Version, Weight,
};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, AnyIterableVec, Computation, EagerVec, File, Format};
use brk_structs::{
CheckedSub, DifficultyEpoch, HalvingEpoch, Height, StoredU32, StoredU64, Timestamp, Version,
Weight,
};
use brk_vecs::{AnyCollectableVec, Computation, EagerVec, Exit, File, Format, VecIterator};
use crate::grouped::Source;
@@ -20,6 +20,8 @@ const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
file: Arc<File>,
pub height_to_interval: EagerVec<Height, Timestamp>,
pub height_to_vbytes: EagerVec<Height, StoredU64>,
pub difficultyepoch_to_timestamp: EagerVec<DifficultyEpoch, Timestamp>,
@@ -27,28 +29,30 @@ pub struct Vecs {
pub timeindexes_to_timestamp: ComputedVecsFromDateIndex<Timestamp>,
pub indexes_to_block_count: ComputedVecsFromHeight<StoredU32>,
pub indexes_to_block_interval: ComputedVecsFromHeight<Timestamp>,
pub indexes_to_block_size: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_block_size: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_block_vbytes: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_block_weight: ComputedVecsFromHeight<Weight>,
}
impl Vecs {
pub fn forced_import(
file: &Arc<File>,
parent: &Path,
version: Version,
computation: Computation,
format: Format,
indexes: &indexes::Vecs,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let file = Arc::new(File::open(&parent.join("blocks"))?);
Ok(Self {
height_to_interval: EagerVec::forced_import(
file,
&file,
"interval",
version + VERSION + Version::ZERO,
format,
)?,
timeindexes_to_timestamp: ComputedVecsFromDateIndex::forced_import(
file,
&file,
"timestamp",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -58,7 +62,7 @@ impl Vecs {
VecBuilderOptions::default().add_first(),
)?,
indexes_to_block_interval: ComputedVecsFromHeight::forced_import(
file,
&file,
"block_interval",
Source::None,
version + VERSION + Version::ZERO,
@@ -71,7 +75,7 @@ impl Vecs {
.add_average(),
)?,
indexes_to_block_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"block_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -81,7 +85,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_block_weight: ComputedVecsFromHeight::forced_import(
file,
&file,
"block_weight",
Source::None,
version + VERSION + Version::ZERO,
@@ -91,7 +95,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_block_size: ComputedVecsFromHeight::forced_import(
file,
&file,
"block_size",
Source::None,
version + VERSION + Version::ZERO,
@@ -101,13 +105,13 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
height_to_vbytes: EagerVec::forced_import(
file,
&file,
"vbytes",
version + VERSION + Version::ZERO,
format,
)?,
indexes_to_block_vbytes: ComputedVecsFromHeight::forced_import(
file,
&file,
"block_vbytes",
Source::None,
version + VERSION + Version::ZERO,
@@ -117,17 +121,19 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
difficultyepoch_to_timestamp: EagerVec::forced_import(
file,
&file,
"timestamp",
version + VERSION + Version::ZERO,
format,
)?,
halvingepoch_to_timestamp: EagerVec::forced_import(
file,
&file,
"timestamp",
version + VERSION + Version::ZERO,
format,
)?,
file,
})
}
@@ -137,7 +143,7 @@ impl Vecs {
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.timeindexes_to_timestamp.compute_all(
indexer,
indexes,
@@ -149,7 +155,8 @@ impl Vecs {
&indexes.dateindex_to_date,
|(di, d, ..)| (di, Timestamp::from(d)),
exit,
)
)?;
Ok(())
},
)?;
@@ -164,7 +171,8 @@ impl Vecs {
&indexer.vecs.height_to_weight,
|h| (h, StoredU32::from(1_u32)),
exit,
)
)?;
Ok(())
},
)?;
@@ -240,6 +248,8 @@ impl Vecs {
exit,
)?;
self.file.flush()?;
self.file.punch_holes()?;
Ok(())
}

155
crates/brk_computer/src/cointime.rs
View File

@@ -1,23 +1,25 @@
use std::sync::Arc;
use std::{path::Path, sync::Arc};
use brk_core::{Bitcoin, CheckedSub, Dollars, StoredF64, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, Computation, File, Format, VecIterator};
use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF64, Version};
use brk_vecs::{AnyCollectableVec, Computation, Exit, File, Format, VecIterator};
use super::{
Indexes, fetched,
Indexes,
grouped::{
ComputedRatioVecsFromDateIndex, ComputedValueVecsFromHeight, ComputedVecsFromHeight,
Source, VecBuilderOptions,
},
indexes, stateful, transactions,
indexes, price, stateful, transactions,
};
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
file: Arc<File>,
pub indexes_to_coinblocks_created: ComputedVecsFromHeight<StoredF64>,
pub indexes_to_coinblocks_stored: ComputedVecsFromHeight<StoredF64>,
pub indexes_to_liveliness: ComputedVecsFromHeight<StoredF64>,
@@ -46,18 +48,20 @@ pub struct Vecs {
impl Vecs {
pub fn forced_import(
file: &Arc<File>,
parent: &Path,
version: Version,
computation: Computation,
format: Format,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
price: Option<&price::Vecs>,
) -> Result<Self> {
let file = Arc::new(File::open(&parent.join("cointime"))?);
let compute_dollars = price.is_some();
Ok(Self {
indexes_to_coinblocks_created: ComputedVecsFromHeight::forced_import(
file,
&file,
"coinblocks_created",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -67,7 +71,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_coinblocks_stored: ComputedVecsFromHeight::forced_import(
file,
&file,
"coinblocks_stored",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -77,7 +81,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_liveliness: ComputedVecsFromHeight::forced_import(
file,
&file,
"liveliness",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -87,7 +91,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_vaultedness: ComputedVecsFromHeight::forced_import(
file,
&file,
"vaultedness",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -97,7 +101,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_activity_to_vaultedness_ratio: ComputedVecsFromHeight::forced_import(
file,
&file,
"activity_to_vaultedness_ratio",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -107,7 +111,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_vaulted_supply: ComputedValueVecsFromHeight::forced_import(
file,
&file,
"vaulted_supply",
Source::Compute,
version + VERSION + Version::ONE,
@@ -118,7 +122,7 @@ impl Vecs {
indexes,
)?,
indexes_to_active_supply: ComputedValueVecsFromHeight::forced_import(
file,
&file,
"active_supply",
Source::Compute,
version + VERSION + Version::ONE,
@@ -129,7 +133,7 @@ impl Vecs {
indexes,
)?,
indexes_to_thermo_cap: ComputedVecsFromHeight::forced_import(
file,
&file,
"thermo_cap",
Source::Compute,
version + VERSION + Version::ONE,
@@ -139,7 +143,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_investor_cap: ComputedVecsFromHeight::forced_import(
file,
&file,
"investor_cap",
Source::Compute,
version + VERSION + Version::ONE,
@@ -149,7 +153,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_vaulted_cap: ComputedVecsFromHeight::forced_import(
file,
&file,
"vaulted_cap",
Source::Compute,
version + VERSION + Version::ONE,
@@ -159,7 +163,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_active_cap: ComputedVecsFromHeight::forced_import(
file,
&file,
"active_cap",
Source::Compute,
version + VERSION + Version::ONE,
@@ -169,7 +173,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_vaulted_price: ComputedVecsFromHeight::forced_import(
file,
&file,
"vaulted_price",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -179,7 +183,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_vaulted_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
file,
&file,
"vaulted_price",
Source::None,
version + VERSION + Version::ZERO,
@@ -189,7 +193,7 @@ impl Vecs {
true,
)?,
indexes_to_active_price: ComputedVecsFromHeight::forced_import(
file,
&file,
"active_price",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -199,7 +203,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_active_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
file,
&file,
"active_price",
Source::None,
version + VERSION + Version::ZERO,
@@ -209,7 +213,7 @@ impl Vecs {
true,
)?,
indexes_to_true_market_mean: ComputedVecsFromHeight::forced_import(
file,
&file,
"true_market_mean",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -219,7 +223,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_true_market_mean_ratio: ComputedRatioVecsFromDateIndex::forced_import(
file,
&file,
"true_market_mean",
Source::None,
version + VERSION + Version::ZERO,
@@ -229,7 +233,7 @@ impl Vecs {
true,
)?,
indexes_to_cointime_value_destroyed: ComputedVecsFromHeight::forced_import(
file,
&file,
"cointime_value_destroyed",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -239,7 +243,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_cointime_value_created: ComputedVecsFromHeight::forced_import(
file,
&file,
"cointime_value_created",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -249,7 +253,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_cointime_value_stored: ComputedVecsFromHeight::forced_import(
file,
&file,
"cointime_value_stored",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -259,7 +263,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_cointime_price: ComputedVecsFromHeight::forced_import(
file,
&file,
"cointime_price",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -269,7 +273,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_cointime_cap: ComputedVecsFromHeight::forced_import(
file,
&file,
"cointime_cap",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -279,7 +283,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_cointime_price_ratio: ComputedRatioVecsFromDateIndex::forced_import(
file,
&file,
"cointime_price",
Source::None,
version + VERSION + Version::ZERO,
@@ -288,6 +292,8 @@ impl Vecs {
indexes,
true,
)?,
file,
})
}
@@ -297,11 +303,11 @@ impl Vecs {
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
transactions: &transactions::Vecs,
stateful: &stateful::Vecs,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
let circulating_supply = &stateful.utxo_cohorts.all.1.height_to_supply;
self.indexes_to_coinblocks_created.compute_all(
@@ -315,7 +321,8 @@ impl Vecs {
circulating_supply,
|(i, v, ..)| (i, StoredF64::from(Bitcoin::from(v))),
exit,
)
)?;
Ok(())
},
)?;
@@ -341,7 +348,8 @@ impl Vecs {
(i, created.checked_sub(destroyed).unwrap())
},
exit,
)
)?;
Ok(())
},
)?;
@@ -360,7 +368,8 @@ impl Vecs {
.height_extra
.unwrap_cumulative(),
exit,
)
)?;
Ok(())
},
)?;
let liveliness = &self.indexes_to_liveliness;
@@ -376,7 +385,8 @@ impl Vecs {
liveliness.height.as_ref().unwrap(),
|(i, v, ..)| (i, StoredF64::from(1.0).checked_sub(v).unwrap()),
exit,
)
)?;
Ok(())
},
)?;
let vaultedness = &self.indexes_to_vaultedness;
@@ -392,14 +402,15 @@ impl Vecs {
liveliness.height.as_ref().unwrap(),
vaultedness.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_vaulted_supply.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
@@ -408,14 +419,15 @@ impl Vecs {
circulating_supply,
vaultedness.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_active_supply.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
@@ -424,11 +436,12 @@ impl Vecs {
circulating_supply,
liveliness.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
if let Some(fetched) = fetched {
if let Some(price) = price {
let realized_cap = stateful
.utxo_cohorts
.all
@@ -465,7 +478,8 @@ impl Vecs {
.unwrap_cumulative(),
|(i, v, ..)| (i, v),
exit,
)
)?;
Ok(())
},
)?;
@@ -480,7 +494,8 @@ impl Vecs {
realized_cap,
self.indexes_to_thermo_cap.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -495,7 +510,8 @@ impl Vecs {
realized_cap,
self.indexes_to_vaultedness.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -510,7 +526,8 @@ impl Vecs {
realized_cap,
self.indexes_to_liveliness.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -525,14 +542,15 @@ impl Vecs {
realized_price,
self.indexes_to_vaultedness.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_vaulted_price_ratio.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(self.indexes_to_vaulted_price.dateindex.unwrap_last()),
@@ -549,14 +567,15 @@ impl Vecs {
realized_price,
self.indexes_to_liveliness.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_active_price_ratio.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(self.indexes_to_active_price.dateindex.unwrap_last()),
@@ -577,14 +596,15 @@ impl Vecs {
.as_ref()
.unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_true_market_mean_ratio.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(self.indexes_to_true_market_mean.dateindex.unwrap_last()),
@@ -600,10 +620,11 @@ impl Vecs {
// The price taken won't be correct for time based indexes
vec.compute_multiply(
starting_indexes.height,
&fetched.chainindexes_to_close.height,
&price.chainindexes_to_close.height,
indexes_to_coinblocks_destroyed.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -615,10 +636,11 @@ impl Vecs {
|vec, _, _, starting_indexes, exit| {
vec.compute_multiply(
starting_indexes.height,
&fetched.chainindexes_to_close.height,
&price.chainindexes_to_close.height,
self.indexes_to_coinblocks_created.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -630,10 +652,11 @@ impl Vecs {
|vec, _, _, starting_indexes, exit| {
vec.compute_multiply(
starting_indexes.height,
&fetched.chainindexes_to_close.height,
&price.chainindexes_to_close.height,
self.indexes_to_coinblocks_stored.height.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -652,7 +675,8 @@ impl Vecs {
.height_extra
.unwrap_cumulative(),
exit,
)
)?;
Ok(())
},
)?;
@@ -667,20 +691,23 @@ impl Vecs {
self.indexes_to_cointime_price.height.as_ref().unwrap(),
circulating_supply,
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_cointime_price_ratio.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(self.indexes_to_cointime_price.dateindex.unwrap_last()),
)?;
}
self.file.flush()?;
self.file.punch_holes()?;
Ok(())
}

58
crates/brk_computer/src/constants.rs
View File

@@ -1,9 +1,9 @@
use std::sync::Arc;
use std::{path::Path, sync::Arc};
use brk_core::{StoredU8, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, AnyVec, Computation, File, Format};
use brk_structs::{StoredU16, Version};
use brk_vecs::{AnyCollectableVec, AnyVec, Computation, Exit, File, Format};
use crate::grouped::Source;
@@ -17,23 +17,27 @@ const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
pub constant_0: ComputedVecsFromHeight<StoredU8>,
pub constant_1: ComputedVecsFromHeight<StoredU8>,
pub constant_50: ComputedVecsFromHeight<StoredU8>,
pub constant_100: ComputedVecsFromHeight<StoredU8>,
file: Arc<File>,
pub constant_0: ComputedVecsFromHeight<StoredU16>,
pub constant_1: ComputedVecsFromHeight<StoredU16>,
pub constant_50: ComputedVecsFromHeight<StoredU16>,
pub constant_100: ComputedVecsFromHeight<StoredU16>,
}
impl Vecs {
pub fn forced_import(
file: &Arc<File>,
parent: &Path,
version: Version,
computation: Computation,
format: Format,
indexes: &indexes::Vecs,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let file = Arc::new(File::open(&parent.join("constants"))?);
Ok(Self {
constant_0: ComputedVecsFromHeight::forced_import(
file,
&file,
"constant_0",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -43,7 +47,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
constant_1: ComputedVecsFromHeight::forced_import(
file,
&file,
"constant_1",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -53,7 +57,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
constant_50: ComputedVecsFromHeight::forced_import(
file,
&file,
"constant_50",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -63,7 +67,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
constant_100: ComputedVecsFromHeight::forced_import(
file,
&file,
"constant_100",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -72,6 +76,8 @@ impl Vecs {
indexes,
VecBuilderOptions::default().add_last(),
)?,
file,
})
}
@@ -81,7 +87,7 @@ impl Vecs {
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.constant_0.compute_all(
indexer,
indexes,
@@ -92,9 +98,10 @@ impl Vecs {
starting_indexes.height,
indexes.height_to_date.len(),
indexes.height_to_date.version(),
|i| (i, StoredU8::new(0)),
|i| (i, StoredU16::new(0)),
exit,
)
)?;
Ok(())
},
)?;
@@ -108,9 +115,10 @@ impl Vecs {
starting_indexes.height,
indexes.height_to_date.len(),
indexes.height_to_date.version(),
|i| (i, StoredU8::new(1)),
|i| (i, StoredU16::new(1)),
exit,
)
)?;
Ok(())
},
)?;
@@ -124,9 +132,10 @@ impl Vecs {
starting_indexes.height,
indexes.height_to_date.len(),
indexes.height_to_date.version(),
|i| (i, StoredU8::new(50)),
|i| (i, StoredU16::new(50)),
exit,
)
)?;
Ok(())
},
)?;
@@ -140,12 +149,15 @@ impl Vecs {
starting_indexes.height,
indexes.height_to_date.len(),
indexes.height_to_date.version(),
|i| (i, StoredU8::new(100)),
|i| (i, StoredU16::new(100)),
exit,
)
)?;
Ok(())
},
)?;
self.file.flush()?;
self.file.punch_holes()?;
Ok(())
}

1274
crates/brk_computer/src/fetched.rs
View File

File diff suppressed because it is too large Load Diff

15
crates/brk_computer/src/grouped/builder_computed.rs
View File

@@ -1,10 +1,11 @@
use std::sync::Arc;
use brk_core::{FromCoarserIndex, Result, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_structs::Version;
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, BoxedAnyIterableVec, CloneableAnyIterableVec, Computation,
ComputedVec, ComputedVecFrom2, File, Format, StoredIndex,
AnyBoxedIterableVec, AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Computation,
ComputedVec, ComputedVecFrom2, Exit, File, Format, FromCoarserIndex, StoredIndex,
};
use crate::grouped::{EagerVecBuilder, VecBuilderOptions};
@@ -44,11 +45,11 @@ where
version: Version,
format: Format,
computation: Computation,
source: Option<BoxedAnyIterableVec<S1I, T>>,
source: Option<AnyBoxedIterableVec<S1I, T>>,
source_extra: &EagerVecBuilder<S1I, T>,
len_source: BoxedAnyIterableVec<I, S2T>,
len_source: AnyBoxedIterableVec<I, S2T>,
options: ComputedVecBuilderOptions,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let only_one_active = options.is_only_one_active();
let suffix = |s: &str| format!("{name}_{s}");

64
crates/brk_computer/src/grouped/builder_eager.rs
View File

@@ -1,11 +1,11 @@
use std::sync::Arc;
use brk_core::{CheckedSub, Result, StoredUsize, Version};
use brk_exit::Exit;
use brk_error::{Error, Result};
use brk_structs::{CheckedSub, StoredU64, Version};
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, AnyVec, EagerVec, File, Format, StoredIndex, StoredType,
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, EagerVec, Exit, File, Format,
GenericStoredVec, StoredIndex, StoredRaw,
};
use color_eyre::eyre::ContextCompat;
use crate::utils::get_percentile;
@@ -44,7 +44,7 @@ where
version: Version,
format: Format,
options: VecBuilderOptions,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let only_one_active = options.is_only_one_active();
let suffix = |s: &str| format!("{name}_{s}");
@@ -213,8 +213,9 @@ where
cumulative_vec.iter().unwrap_get_inner(index)
});
source.iter_at(index).try_for_each(|(i, v)| -> Result<()> {
cumulative = cumulative.clone() + v.into_owned();
cumulative_vec.forced_push_at(i, cumulative.clone(), exit)
cumulative += v.into_owned();
cumulative_vec.forced_push_at(i, cumulative, exit)?;
Ok(())
})?;
self.safe_flush(exit)?;
@@ -227,11 +228,11 @@ where
max_from: I,
source: &impl AnyIterableVec<I2, T>,
first_indexes: &impl AnyIterableVec<I, I2>,
count_indexes: &impl AnyIterableVec<I, StoredUsize>,
count_indexes: &impl AnyIterableVec<I, StoredU64>,
exit: &Exit,
) -> Result<()>
where
I2: StoredIndex + StoredType + CheckedSub<I2>,
I2: StoredIndex + StoredRaw + CheckedSub<I2>,
{
self.validate_computed_version_or_reset_file(
source.version() + first_indexes.version() + count_indexes.version(),
@@ -265,7 +266,7 @@ where
}
if let Some(last) = self.last.as_mut() {
let count_index = *count_index;
let count_index = *count_index as usize;
if count_index == 0 {
panic!("should compute last if count can be 0")
}
@@ -295,7 +296,7 @@ where
if needs_values {
source_iter.set(first_index);
let mut values = (&mut source_iter)
.take(*count_index)
.take(*count_index as usize)
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
@@ -305,9 +306,9 @@ where
if let Some(max) = self.max.as_mut() {
max.forced_push_at(
i,
values
*values
.last()
.context("expect some")
.ok_or(Error::Str("expect some"))
.inspect_err(|_| {
dbg!(
&values,
@@ -320,8 +321,7 @@ where
source.name()
);
})
.unwrap()
.clone(),
.unwrap(),
exit,
)?;
}
@@ -347,7 +347,7 @@ where
}
if let Some(min) = self.min.as_mut() {
min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
min.forced_push_at(i, *values.first().unwrap(), exit)?;
}
}
@@ -356,18 +356,18 @@ where
let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
if let Some(average) = self.average.as_mut() {
let avg = sum.clone() / len;
let avg = sum / len;
average.forced_push_at(i, avg, exit)?;
}
if needs_sum_or_cumulative {
if let Some(sum_vec) = self.sum.as_mut() {
sum_vec.forced_push_at(i, sum.clone(), exit)?;
sum_vec.forced_push_at(i, sum, exit)?;
}
if let Some(cumulative_vec) = self.cumulative.as_mut() {
let t = cumulative.as_ref().unwrap().clone() + sum;
cumulative.replace(t.clone());
let t = cumulative.unwrap() + sum;
cumulative.replace(t);
cumulative_vec.forced_push_at(i, t, exit)?;
}
}
@@ -388,11 +388,11 @@ where
max_from: I,
source: &EagerVecBuilder<I2, T>,
first_indexes: &impl AnyIterableVec<I, I2>,
count_indexes: &impl AnyIterableVec<I, StoredUsize>,
count_indexes: &impl AnyIterableVec<I, StoredU64>,
exit: &Exit,
) -> Result<()>
where
I2: StoredIndex + StoredType + CheckedSub<I2>,
I2: StoredIndex + StoredRaw + CheckedSub<I2>,
{
if self._90p.is_some()
|| self._75p.is_some()
@@ -440,7 +440,7 @@ where
}
if let Some(last) = self.last.as_mut() {
let count_index = *count_index;
let count_index = *count_index as usize;
if count_index == 0 {
panic!("should compute last if count can be 0")
}
@@ -464,22 +464,22 @@ where
let source_max_iter = source_max_iter.as_mut().unwrap();
source_max_iter.set(first_index);
let mut values = source_max_iter
.take(*count_index)
.take(*count_index as usize)
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
values.sort_unstable();
max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
max.forced_push_at(i, *values.last().unwrap(), exit)?;
}
if let Some(min) = self.min.as_mut() {
let source_min_iter = source_min_iter.as_mut().unwrap();
source_min_iter.set(first_index);
let mut values = source_min_iter
.take(*count_index)
.take(*count_index as usize)
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
values.sort_unstable();
min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
min.forced_push_at(i, *values.first().unwrap(), exit)?;
}
}
@@ -488,7 +488,7 @@ where
let source_average_iter = source_average_iter.as_mut().unwrap();
source_average_iter.set(first_index);
let values = source_average_iter
.take(*count_index)
.take(*count_index as usize)
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
@@ -504,19 +504,19 @@ where
let source_sum_iter = source_sum_iter.as_mut().unwrap();
source_sum_iter.set(first_index);
let values = source_sum_iter
.take(*count_index)
.take(*count_index as usize)
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
if let Some(sum_vec) = self.sum.as_mut() {
sum_vec.forced_push_at(i, sum.clone(), exit)?;
sum_vec.forced_push_at(i, sum, exit)?;
}
if let Some(cumulative_vec) = self.cumulative.as_mut() {
let t = cumulative.as_ref().unwrap().clone() + sum;
cumulative.replace(t.clone());
let t = cumulative.unwrap() + sum;
cumulative.replace(t);
cumulative_vec.forced_push_at(i, t, exit)?;
}
}

23
crates/brk_computer/src/grouped/computed.rs Normal file
View File

@@ -0,0 +1,23 @@
use std::ops::{Add, AddAssign, Div};
use brk_vecs::StoredCompressed;
pub trait ComputedType
where
Self: StoredCompressed
+ From<usize>
+ Div<usize, Output = Self>
+ Add<Output = Self>
+ AddAssign
+ Ord,
{
}
impl<T> ComputedType for T where
T: StoredCompressed
+ From<usize>
+ Div<usize, Output = Self>
+ Add<Output = Self>
+ AddAssign
+ Ord
{
}

19
crates/brk_computer/src/grouped/from_dateindex.rs
View File

@@ -1,13 +1,14 @@
use std::sync::Arc;
use brk_core::{
DateIndex, DecadeIndex, MonthIndex, QuarterIndex, Result, SemesterIndex, Version, WeekIndex,
YearIndex,
};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{
DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, CloneableAnyIterableVec, Computation, EagerVec, File, Format,
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Computation, EagerVec, Exit, File,
Format,
};
use crate::{Indexes, grouped::ComputedVecBuilder, indexes};
@@ -45,7 +46,7 @@ where
computation: Computation,
indexes: &indexes::Vecs,
options: VecBuilderOptions,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let dateindex = source.is_compute().then(|| {
EagerVec::forced_import(file, name, version + VERSION + Version::ZERO, format).unwrap()
});
@@ -141,7 +142,7 @@ where
starting_indexes: &Indexes,
exit: &Exit,
mut compute: F,
) -> color_eyre::Result<()>
) -> Result<()>
where
F: FnMut(
&mut EagerVec<DateIndex, T>,
@@ -169,7 +170,7 @@ where
starting_indexes: &Indexes,
exit: &Exit,
dateindex: Option<&impl AnyIterableVec<DateIndex, T>>,
) -> color_eyre::Result<()> {
) -> Result<()> {
if let Some(dateindex) = dateindex {
self.dateindex_extra
.extend(starting_indexes.dateindex, dateindex, exit)?;

20
crates/brk_computer/src/grouped/from_height.rs
View File

@@ -1,13 +1,15 @@
use std::sync::Arc;
use brk_core::{
DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, Result,
SemesterIndex, Version, WeekIndex, YearIndex,
};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{
DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex,
Version, WeekIndex, YearIndex,
};
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, CloneableAnyIterableVec, Computation, EagerVec, File, Format,
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Computation, EagerVec, Exit, File,
Format,
};
use crate::{
@@ -53,7 +55,7 @@ where
computation: Computation,
indexes: &indexes::Vecs,
options: VecBuilderOptions,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let height = source.is_compute().then(|| {
EagerVec::forced_import(file, name, version + VERSION + Version::ZERO, format).unwrap()
});
@@ -164,7 +166,7 @@ where
starting_indexes: &Indexes,
exit: &Exit,
mut compute: F,
) -> color_eyre::Result<()>
) -> Result<()>
where
F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>,
{
@@ -186,7 +188,7 @@ where
starting_indexes: &Indexes,
exit: &Exit,
height_vec: Option<&impl AnyIterableVec<Height, T>>,
) -> color_eyre::Result<()> {
) -> Result<()> {
if let Some(height) = height_vec {
self.height_extra
.extend(starting_indexes.height, height, exit)?;

11
crates/brk_computer/src/grouped/from_height_strict.rs
View File

@@ -1,9 +1,10 @@
use std::sync::Arc;
use brk_core::{DifficultyEpoch, Height, Result, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, EagerVec, File, Format};
use brk_structs::{DifficultyEpoch, Height, Version};
use brk_vecs::{AnyCollectableVec, EagerVec, Exit, File, Format};
use crate::{Indexes, indexes};
@@ -33,7 +34,7 @@ where
version: Version,
format: Format,
options: VecBuilderOptions,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let height =
EagerVec::forced_import(file, name, version + VERSION + Version::ZERO, format)?;
@@ -68,7 +69,7 @@ where
starting_indexes: &Indexes,
exit: &Exit,
mut compute: F,
) -> color_eyre::Result<()>
) -> Result<()>
where
F: FnMut(&mut EagerVec<Height, T>, &Indexer, &indexes::Vecs, &Indexes, &Exit) -> Result<()>,
{

26
crates/brk_computer/src/grouped/from_txindex.rs
View File

@@ -1,20 +1,20 @@
use std::sync::Arc;
use brk_core::{
Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
Result, Sats, SemesterIndex, TxIndex, Version, WeekIndex, YearIndex,
};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{
Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
Sats, SemesterIndex, TxIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::{
AnyCollectableVec, AnyVec, CloneableAnyIterableVec, CollectableVec, Computation, EagerVec,
File, Format, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyCollectableVec, AnyVec, CollectableVec, Computation, EagerVec,
Exit, File, Format, GenericStoredVec, StoredIndex, VecIterator,
};
use crate::{
Indexes, fetched,
Indexes,
grouped::{ComputedVecBuilder, Source},
indexes,
indexes, price,
};
use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
@@ -54,7 +54,7 @@ where
computation: Computation,
indexes: &indexes::Vecs,
options: VecBuilderOptions,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let txindex = source.is_compute().then(|| {
Box::new(
EagerVec::forced_import(file, name, version + VERSION + Version::ZERO, format)
@@ -170,7 +170,7 @@ where
// starting_indexes: &Indexes,
// exit: &Exit,
// mut compute: F,
// ) -> color_eyre::Result<()>
// ) -> Result<()>
// where
// F: FnMut(
// &mut EagerVec<TxIndex, T>,
@@ -495,7 +495,7 @@ impl ComputedVecsFromTxindex<Dollars> {
exit: &Exit,
bitcoin: &ComputedVecsFromTxindex<Bitcoin>,
txindex: Option<&impl CollectableVec<TxIndex, Dollars>>,
fetched: &fetched::Vecs,
price: &price::Vecs,
) -> Result<()> {
let txindex_version = if let Some(txindex) = txindex {
txindex.version()
@@ -508,7 +508,7 @@ impl ComputedVecsFromTxindex<Dollars> {
let starting_index = self.height.starting_index(starting_indexes.height);
let mut close_iter = fetched.chainindexes_to_close.height.into_iter();
let mut close_iter = price.chainindexes_to_close.height.into_iter();
(starting_index.unwrap_to_usize()..indexer.vecs.height_to_weight.len())
.map(Height::from)

4
crates/brk_computer/src/grouped/mod.rs
View File

@@ -1,12 +1,12 @@
mod builder_computed;
mod builder_eager;
mod computed;
mod from_dateindex;
mod from_height;
mod from_height_strict;
mod from_txindex;
mod ratio_from_dateindex;
mod source;
mod r#type;
mod value_from_dateindex;
mod value_from_height;
mod value_from_txindex;
@@ -14,13 +14,13 @@ mod value_height;
pub use builder_computed::*;
pub use builder_eager::*;
use computed::*;
pub use from_dateindex::*;
pub use from_height::*;
pub use from_height_strict::*;
pub use from_txindex::*;
pub use ratio_from_dateindex::*;
pub use source::*;
use r#type::*;
pub use value_from_dateindex::*;
pub use value_from_height::*;
pub use value_from_txindex::*;

93
crates/brk_computer/src/grouped/ratio_from_dateindex.rs
View File

@@ -1,14 +1,14 @@
use std::{f32, sync::Arc};
use brk_core::{Date, DateIndex, Dollars, Result, StoredF32, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version};
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, AnyVec, CollectableVec, Computation, EagerVec, File, Format,
StoredIndex, VecIterator,
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Computation, EagerVec,
Exit, File, Format, GenericStoredVec, StoredIndex, VecIterator,
};
use crate::{Indexes, fetched, grouped::source::Source, indexes, utils::get_percentile};
use crate::{Indexes, grouped::source::Source, indexes, price, utils::get_percentile};
use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
@@ -68,7 +68,7 @@ impl ComputedRatioVecsFromDateIndex {
computation: Computation,
indexes: &indexes::Vecs,
extended: bool,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let options = VecBuilderOptions::default().add_last();
Ok(Self {
@@ -570,11 +570,11 @@ impl ComputedRatioVecsFromDateIndex {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: &fetched::Vecs,
price: &price::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
compute: F,
) -> color_eyre::Result<()>
) -> Result<()>
where
F: FnMut(
&mut EagerVec<DateIndex, Dollars>,
@@ -596,7 +596,7 @@ impl ComputedRatioVecsFromDateIndex {
self.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
date_to_price_opt,
@@ -607,16 +607,16 @@ impl ComputedRatioVecsFromDateIndex {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: &fetched::Vecs,
price: &price::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
date_to_price_opt: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
) -> color_eyre::Result<()> {
) -> Result<()> {
let date_to_price = date_to_price_opt.unwrap_or_else(|| unsafe {
std::mem::transmute(&self.price.as_ref().unwrap().dateindex)
});
let closes = fetched.timeindexes_to_close.dateindex.as_ref().unwrap();
let closes = price.timeindexes_to_close.dateindex.as_ref().unwrap();
self.ratio.compute_all(
indexer,
@@ -637,7 +637,8 @@ impl ComputedRatioVecsFromDateIndex {
}
},
exit,
)
)?;
Ok(())
},
)?;
@@ -659,7 +660,8 @@ impl ComputedRatioVecsFromDateIndex {
usize::MAX,
exit,
Some(min_ratio_date),
)
)?;
Ok(())
},
)?;
@@ -675,7 +677,8 @@ impl ComputedRatioVecsFromDateIndex {
7,
exit,
Some(min_ratio_date),
)
)?;
Ok(())
},
)?;
@@ -691,7 +694,8 @@ impl ComputedRatioVecsFromDateIndex {
30,
exit,
Some(min_ratio_date),
)
)?;
Ok(())
},
)?;
@@ -707,7 +711,8 @@ impl ComputedRatioVecsFromDateIndex {
365,
exit,
Some(min_ratio_date),
)
)?;
Ok(())
},
)?;
@@ -723,7 +728,8 @@ impl ComputedRatioVecsFromDateIndex {
4 * 365,
exit,
Some(min_ratio_date),
)
)?;
Ok(())
},
)?;
@@ -756,7 +762,8 @@ impl ComputedRatioVecsFromDateIndex {
)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -766,7 +773,8 @@ impl ComputedRatioVecsFromDateIndex {
.try_for_each(|v| -> Result<()> {
v.validate_computed_version_or_reset_file(
Version::ZERO + v.inner_version() + ratio_version,
)
)?;
Ok(())
})?;
let starting_dateindex = self
@@ -1194,7 +1202,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1220,7 +1229,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1246,7 +1256,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1272,7 +1283,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1298,7 +1310,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1324,7 +1337,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1350,7 +1364,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1376,7 +1391,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1402,7 +1418,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1428,7 +1445,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1454,7 +1472,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1480,7 +1499,8 @@ impl ComputedRatioVecsFromDateIndex {
(i, price * multiplier)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1496,7 +1516,8 @@ impl ComputedRatioVecsFromDateIndex {
self.ratio_sma.as_ref().unwrap().dateindex.as_ref().unwrap(),
self.ratio_sd.as_ref().unwrap().dateindex.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -1522,7 +1543,8 @@ impl ComputedRatioVecsFromDateIndex {
.as_ref()
.unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -1548,7 +1570,8 @@ impl ComputedRatioVecsFromDateIndex {
.as_ref()
.unwrap(),
exit,
)
)?;
Ok(())
},
)?;

14
crates/brk_computer/src/grouped/source.rs
View File

@@ -1,10 +1,10 @@
use brk_vecs::BoxedAnyIterableVec;
use brk_vecs::AnyBoxedIterableVec;
#[derive(Clone)]
pub enum Source<I, T> {
Compute,
None,
Vec(BoxedAnyIterableVec<I, T>),
Vec(AnyBoxedIterableVec<I, T>),
}
impl<I, T> Source<I, T> {
@@ -20,7 +20,7 @@ impl<I, T> Source<I, T> {
matches!(self, Self::Vec(_))
}
pub fn vec(self) -> Option<BoxedAnyIterableVec<I, T>> {
pub fn vec(self) -> Option<AnyBoxedIterableVec<I, T>> {
match self {
Self::Vec(v) => Some(v),
_ => None,
@@ -34,14 +34,14 @@ impl<I, T> From<bool> for Source<I, T> {
}
}
impl<I, T> From<BoxedAnyIterableVec<I, T>> for Source<I, T> {
fn from(value: BoxedAnyIterableVec<I, T>) -> Self {
impl<I, T> From<AnyBoxedIterableVec<I, T>> for Source<I, T> {
fn from(value: AnyBoxedIterableVec<I, T>) -> Self {
Self::Vec(value)
}
}
impl<I, T> From<Option<BoxedAnyIterableVec<I, T>>> for Source<I, T> {
fn from(value: Option<BoxedAnyIterableVec<I, T>>) -> Self {
impl<I, T> From<Option<AnyBoxedIterableVec<I, T>>> for Source<I, T> {
fn from(value: Option<AnyBoxedIterableVec<I, T>>) -> Self {
if let Some(v) = value {
Self::Vec(v)
} else {

14
crates/brk_computer/src/grouped/type.rs
View File

@@ -1,14 +0,0 @@
use std::ops::{Add, AddAssign, Div};
use brk_vecs::StoredType;
pub trait ComputedType
where
Self:
StoredType + From<usize> + Div<usize, Output = Self> + Add<Output = Self> + AddAssign + Ord,
{
}
impl<T> ComputedType for T where
T: StoredType + From<usize> + Div<usize, Output = Self> + Add<Output = Self> + AddAssign + Ord
{
}

29
crates/brk_computer/src/grouped/value_from_dateindex.rs
View File

@@ -1,11 +1,18 @@
use std::sync::Arc;
use brk_core::{Bitcoin, DateIndex, Dollars, Result, Sats, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, CollectableVec, Computation, EagerVec, File, Format, StoredVec};
use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version};
use brk_vecs::{
AnyCollectableVec, CollectableVec, Computation, EagerVec, Exit, File, Format, StoredVec,
};
use crate::{Indexes, fetched, grouped::ComputedVecsFromDateIndex, indexes};
use crate::{
Indexes,
grouped::ComputedVecsFromDateIndex,
indexes, price,
traits::{ComputeFromBitcoin, ComputeFromSats},
};
use super::{Source, VecBuilderOptions};
@@ -30,7 +37,7 @@ impl ComputedValueVecsFromDateIndex {
options: VecBuilderOptions,
compute_dollars: bool,
indexes: &indexes::Vecs,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
Ok(Self {
sats: ComputedVecsFromDateIndex::forced_import(
file,
@@ -72,11 +79,11 @@ impl ComputedValueVecsFromDateIndex {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
mut compute: F,
) -> color_eyre::Result<()>
) -> Result<()>
where
F: FnMut(
&mut EagerVec<DateIndex, Sats>,
@@ -95,7 +102,7 @@ impl ComputedValueVecsFromDateIndex {
)?;
let dateindex: Option<&StoredVec<DateIndex, Sats>> = None;
self.compute_rest(indexer, indexes, fetched, starting_indexes, exit, dateindex)?;
self.compute_rest(indexer, indexes, price, starting_indexes, exit, dateindex)?;
Ok(())
}
@@ -104,11 +111,11 @@ impl ComputedValueVecsFromDateIndex {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
dateindex: Option<&impl CollectableVec<DateIndex, Sats>>,
) -> color_eyre::Result<()> {
) -> Result<()> {
if let Some(dateindex) = dateindex {
self.sats
.compute_rest(indexes, starting_indexes, exit, Some(dateindex))?;
@@ -144,7 +151,7 @@ impl ComputedValueVecsFromDateIndex {
}
let dateindex_to_bitcoin = self.bitcoin.dateindex.as_ref().unwrap();
let dateindex_to_close = fetched
let dateindex_to_close = price
.as_ref()
.unwrap()
.timeindexes_to_close

29
crates/brk_computer/src/grouped/value_from_height.rs
View File

@@ -1,11 +1,18 @@
use std::sync::Arc;
use brk_core::{Bitcoin, Dollars, Height, Result, Sats, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, CollectableVec, Computation, EagerVec, File, Format, StoredVec};
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use brk_vecs::{
AnyCollectableVec, CollectableVec, Computation, EagerVec, Exit, File, Format, StoredVec,
};
use crate::{Indexes, fetched, grouped::Source, indexes};
use crate::{
Indexes,
grouped::Source,
indexes, price,
traits::{ComputeFromBitcoin, ComputeFromSats},
};
use super::{ComputedVecsFromHeight, VecBuilderOptions};
@@ -30,7 +37,7 @@ impl ComputedValueVecsFromHeight {
options: VecBuilderOptions,
compute_dollars: bool,
indexes: &indexes::Vecs,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
Ok(Self {
sats: ComputedVecsFromHeight::forced_import(
file,
@@ -72,11 +79,11 @@ impl ComputedValueVecsFromHeight {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
mut compute: F,
) -> color_eyre::Result<()>
) -> Result<()>
where
F: FnMut(
&mut EagerVec<Height, Sats>,
@@ -95,7 +102,7 @@ impl ComputedValueVecsFromHeight {
)?;
let height: Option<&StoredVec<Height, Sats>> = None;
self.compute_rest(indexer, indexes, fetched, starting_indexes, exit, height)?;
self.compute_rest(indexer, indexes, price, starting_indexes, exit, height)?;
Ok(())
}
@@ -104,11 +111,11 @@ impl ComputedValueVecsFromHeight {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
height: Option<&impl CollectableVec<Height, Sats>>,
) -> color_eyre::Result<()> {
) -> Result<()> {
if let Some(height) = height {
self.sats
.compute_rest(indexes, starting_indexes, exit, Some(height))?;
@@ -144,7 +151,7 @@ impl ComputedValueVecsFromHeight {
}
let height_to_bitcoin = self.bitcoin.height.as_ref().unwrap();
let height_to_close = &fetched.as_ref().unwrap().chainindexes_to_close.height;
let height_to_close = &price.as_ref().unwrap().chainindexes_to_close.height;
if let Some(dollars) = self.dollars.as_mut() {
dollars.compute_all(

30
crates/brk_computer/src/grouped/value_from_txindex.rs
View File

@@ -1,14 +1,14 @@
use std::sync::Arc;
use brk_core::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
use brk_vecs::{
AnyCollectableVec, CloneableAnyIterableVec, CollectableVec, Computation, ComputedVecFrom3,
File, Format, LazyVecFrom1, StoredIndex, StoredVec,
AnyCloneableIterableVec, AnyCollectableVec, CollectableVec, Computation, ComputedVecFrom3,
Exit, File, Format, LazyVecFrom1, StoredIndex, StoredVec,
};
use crate::{Indexes, fetched, grouped::Source, indexes};
use crate::{Indexes, grouped::Source, indexes, price};
use super::{ComputedVecsFromTxindex, VecBuilderOptions};
@@ -45,10 +45,10 @@ impl ComputedValueVecsFromTxindex {
version: Version,
computation: Computation,
format: Format,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
options: VecBuilderOptions,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
) -> Result<Self> {
let compute_dollars = price.is_some();
let name_in_btc = format!("{name}_in_btc");
let name_in_usd = format!("{name}_in_usd");
@@ -89,7 +89,7 @@ impl ComputedValueVecsFromTxindex {
options,
)?;
let dollars_txindex = fetched.map(|fetched| {
let dollars_txindex = price.map(|price| {
ComputedVecFrom3::forced_import_or_init_from_3(
computation,
file,
@@ -98,7 +98,7 @@ impl ComputedValueVecsFromTxindex {
format,
bitcoin_txindex.boxed_clone(),
indexes.txindex_to_height.boxed_clone(),
fetched.chainindexes_to_close.height.boxed_clone(),
price.chainindexes_to_close.height.boxed_clone(),
|txindex: TxIndex,
txindex_to_btc_iter,
txindex_to_height_iter,
@@ -145,11 +145,11 @@ impl ComputedValueVecsFromTxindex {
// &mut self,
// indexer: &Indexer,
// indexes: &indexes::Vecs,
// fetched: Option<&marketprice::Vecs>,
// price: Option<&marketprice::Vecs>,
// starting_indexes: &Indexes,
// exit: &Exit,
// mut compute: F,
// ) -> color_eyre::Result<()>
// ) -> Result<()>
// where
// F: FnMut(
// &mut EagerVec<TxIndex, Sats>,
@@ -187,8 +187,8 @@ impl ComputedValueVecsFromTxindex {
starting_indexes: &Indexes,
exit: &Exit,
txindex: Option<&impl CollectableVec<TxIndex, Sats>>,
fetched: Option<&fetched::Vecs>,
) -> color_eyre::Result<()> {
price: Option<&price::Vecs>,
) -> Result<()> {
if let Some(txindex) = txindex {
self.sats
.compute_rest(indexer, indexes, starting_indexes, exit, Some(txindex))?;
@@ -223,7 +223,7 @@ impl ComputedValueVecsFromTxindex {
exit,
&self.bitcoin,
Some(dollars_txindex),
fetched.as_ref().unwrap(),
price.as_ref().unwrap(),
)?;
}

27
crates/brk_computer/src/grouped/value_height.rs
View File

@@ -1,11 +1,16 @@
use std::sync::Arc;
use brk_core::{Bitcoin, Dollars, Height, Result, Sats, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, CollectableVec, EagerVec, File, Format, StoredVec};
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use brk_vecs::{AnyCollectableVec, CollectableVec, EagerVec, Exit, File, Format, StoredVec};
use crate::{Indexes, fetched, grouped::Source, indexes};
use crate::{
Indexes,
grouped::Source,
indexes, price,
traits::{ComputeFromBitcoin, ComputeFromSats},
};
#[derive(Clone)]
pub struct ComputedHeightValueVecs {
@@ -24,7 +29,7 @@ impl ComputedHeightValueVecs {
version: Version,
format: Format,
compute_dollars: bool,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
Ok(Self {
sats: source.is_compute().then(|| {
EagerVec::forced_import(file, name, version + VERSION + Version::ZERO, format)
@@ -52,11 +57,11 @@ impl ComputedHeightValueVecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
mut compute: F,
) -> color_eyre::Result<()>
) -> Result<()>
where
F: FnMut(
&mut EagerVec<Height, Sats>,
@@ -75,18 +80,18 @@ impl ComputedHeightValueVecs {
)?;
let height: Option<&StoredVec<Height, Sats>> = None;
self.compute_rest(fetched, starting_indexes, exit, height)?;
self.compute_rest(price, starting_indexes, exit, height)?;
Ok(())
}
pub fn compute_rest(
&mut self,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
height: Option<&impl CollectableVec<Height, Sats>>,
) -> color_eyre::Result<()> {
) -> Result<()> {
if let Some(height) = height {
self.bitcoin
.compute_from_sats(starting_indexes.height, height, exit)?;
@@ -99,7 +104,7 @@ impl ComputedHeightValueVecs {
}
let height_to_bitcoin = &self.bitcoin;
let height_to_close = &fetched.as_ref().unwrap().chainindexes_to_close.height;
let height_to_close = &price.as_ref().unwrap().chainindexes_to_close.height;
if let Some(dollars) = self.dollars.as_mut() {
dollars.compute_from_bitcoin(

175
crates/brk_computer/src/indexes.rs
View File

@@ -1,36 +1,38 @@
use std::{ops::Deref, sync::Arc};
use std::{ops::Deref, path::Path, sync::Arc};
use brk_core::{
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{
Date, DateIndex, DecadeIndex, DifficultyEpoch, EmptyOutputIndex, HalvingEpoch, Height,
InputIndex, MonthIndex, OpReturnIndex, OutputIndex, P2AAddressIndex, P2ABytes, P2MSOutputIndex,
P2PK33AddressIndex, P2PK33Bytes, P2PK65AddressIndex, P2PK65Bytes, P2PKHAddressIndex,
P2PKHBytes, P2SHAddressIndex, P2SHBytes, P2TRAddressIndex, P2TRBytes, P2WPKHAddressIndex,
P2WPKHBytes, P2WSHAddressIndex, P2WSHBytes, QuarterIndex, Sats, SemesterIndex, StoredUsize,
P2WPKHBytes, P2WSHAddressIndex, P2WSHBytes, QuarterIndex, Sats, SemesterIndex, StoredU64,
Timestamp, TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, YearIndex,
};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_vecs::{
AnyCollectableVec, CloneableAnyIterableVec, Computation, ComputedVec, ComputedVecFrom1,
ComputedVecFrom2, EagerVec, File, Format, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyCollectableVec, Computation, ComputedVec, ComputedVecFrom1,
ComputedVecFrom2, EagerVec, Exit, File, Format, StoredIndex, VecIterator,
};
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
file: Arc<File>,
pub dateindex_to_date: EagerVec<DateIndex, Date>,
pub dateindex_to_dateindex: EagerVec<DateIndex, DateIndex>,
pub dateindex_to_first_height: EagerVec<DateIndex, Height>,
pub dateindex_to_height_count: EagerVec<DateIndex, StoredUsize>,
pub dateindex_to_height_count: EagerVec<DateIndex, StoredU64>,
pub dateindex_to_monthindex: EagerVec<DateIndex, MonthIndex>,
pub dateindex_to_weekindex: EagerVec<DateIndex, WeekIndex>,
pub decadeindex_to_decadeindex: EagerVec<DecadeIndex, DecadeIndex>,
pub decadeindex_to_first_yearindex: EagerVec<DecadeIndex, YearIndex>,
pub decadeindex_to_yearindex_count: EagerVec<DecadeIndex, StoredUsize>,
pub decadeindex_to_yearindex_count: EagerVec<DecadeIndex, StoredU64>,
pub difficultyepoch_to_difficultyepoch: EagerVec<DifficultyEpoch, DifficultyEpoch>,
pub difficultyepoch_to_first_height: EagerVec<DifficultyEpoch, Height>,
pub difficultyepoch_to_height_count: EagerVec<DifficultyEpoch, StoredUsize>,
pub difficultyepoch_to_height_count: EagerVec<DifficultyEpoch, StoredU64>,
pub emptyoutputindex_to_emptyoutputindex:
ComputedVecFrom1<EmptyOutputIndex, EmptyOutputIndex, EmptyOutputIndex, TxIndex>,
pub halvingepoch_to_first_height: EagerVec<HalvingEpoch, Height>,
@@ -42,9 +44,9 @@ pub struct Vecs {
pub height_to_halvingepoch: EagerVec<Height, HalvingEpoch>,
pub height_to_height: EagerVec<Height, Height>,
pub height_to_timestamp_fixed: EagerVec<Height, Timestamp>,
pub height_to_txindex_count: EagerVec<Height, StoredUsize>,
pub height_to_txindex_count: EagerVec<Height, StoredU64>,
pub inputindex_to_inputindex: ComputedVecFrom1<InputIndex, InputIndex, InputIndex, OutputIndex>,
pub monthindex_to_dateindex_count: EagerVec<MonthIndex, StoredUsize>,
pub monthindex_to_dateindex_count: EagerVec<MonthIndex, StoredU64>,
pub monthindex_to_first_dateindex: EagerVec<MonthIndex, DateIndex>,
pub monthindex_to_monthindex: EagerVec<MonthIndex, MonthIndex>,
pub monthindex_to_quarterindex: EagerVec<MonthIndex, QuarterIndex>,
@@ -73,39 +75,41 @@ pub struct Vecs {
pub p2wshaddressindex_to_p2wshaddressindex:
ComputedVecFrom1<P2WSHAddressIndex, P2WSHAddressIndex, P2WSHAddressIndex, P2WSHBytes>,
pub quarterindex_to_first_monthindex: EagerVec<QuarterIndex, MonthIndex>,
pub quarterindex_to_monthindex_count: EagerVec<QuarterIndex, StoredUsize>,
pub quarterindex_to_monthindex_count: EagerVec<QuarterIndex, StoredU64>,
pub quarterindex_to_quarterindex: EagerVec<QuarterIndex, QuarterIndex>,
pub semesterindex_to_first_monthindex: EagerVec<SemesterIndex, MonthIndex>,
pub semesterindex_to_monthindex_count: EagerVec<SemesterIndex, StoredUsize>,
pub semesterindex_to_monthindex_count: EagerVec<SemesterIndex, StoredU64>,
pub semesterindex_to_semesterindex: EagerVec<SemesterIndex, SemesterIndex>,
pub txindex_to_height: EagerVec<TxIndex, Height>,
pub txindex_to_input_count:
ComputedVecFrom2<TxIndex, StoredUsize, TxIndex, InputIndex, InputIndex, OutputIndex>,
ComputedVecFrom2<TxIndex, StoredU64, TxIndex, InputIndex, InputIndex, OutputIndex>,
pub txindex_to_output_count:
ComputedVecFrom2<TxIndex, StoredUsize, TxIndex, OutputIndex, OutputIndex, Sats>,
ComputedVecFrom2<TxIndex, StoredU64, TxIndex, OutputIndex, OutputIndex, Sats>,
pub txindex_to_txindex: ComputedVecFrom1<TxIndex, TxIndex, TxIndex, Txid>,
pub unknownoutputindex_to_unknownoutputindex:
ComputedVecFrom1<UnknownOutputIndex, UnknownOutputIndex, UnknownOutputIndex, TxIndex>,
pub weekindex_to_dateindex_count: EagerVec<WeekIndex, StoredUsize>,
pub weekindex_to_dateindex_count: EagerVec<WeekIndex, StoredU64>,
pub weekindex_to_first_dateindex: EagerVec<WeekIndex, DateIndex>,
pub weekindex_to_weekindex: EagerVec<WeekIndex, WeekIndex>,
pub yearindex_to_decadeindex: EagerVec<YearIndex, DecadeIndex>,
pub yearindex_to_first_monthindex: EagerVec<YearIndex, MonthIndex>,
pub yearindex_to_monthindex_count: EagerVec<YearIndex, StoredUsize>,
pub yearindex_to_monthindex_count: EagerVec<YearIndex, StoredU64>,
pub yearindex_to_yearindex: EagerVec<YearIndex, YearIndex>,
}
impl Vecs {
pub fn forced_import(
file: &Arc<File>,
parent: &Path,
version: Version,
indexer: &Indexer,
computation: Computation,
format: Format,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let file = Arc::new(File::open(&parent.join("indexes"))?);
let outputindex_to_outputindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"outputindex",
version + VERSION + Version::ZERO,
format,
@@ -115,7 +119,7 @@ impl Vecs {
let inputindex_to_inputindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"inputindex",
version + VERSION + Version::ZERO,
format,
@@ -125,7 +129,7 @@ impl Vecs {
let txindex_to_txindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"txindex",
version + VERSION + Version::ZERO,
format,
@@ -135,7 +139,7 @@ impl Vecs {
let txindex_to_input_count = ComputedVec::forced_import_or_init_from_2(
computation,
file,
&file,
"input_count",
version + VERSION + Version::ZERO,
format,
@@ -151,14 +155,14 @@ impl Vecs {
.next_at(txindex + 1)
.map(|(_, v)| usize::from(v.into_owned()))
.unwrap_or_else(|| inputindex_to_outputindex_iter.len());
StoredUsize::from((start..end).count())
StoredU64::from((start..end).count())
})
},
)?;
let txindex_to_output_count = ComputedVec::forced_import_or_init_from_2(
computation,
file,
&file,
"output_count",
version + VERSION + Version::ZERO,
format,
@@ -174,14 +178,14 @@ impl Vecs {
.next_at(txindex + 1)
.map(|(_, v)| usize::from(v.into_owned()))
.unwrap_or_else(|| outputindex_to_value_iter.len());
StoredUsize::from((start..end).count())
StoredU64::from((start..end).count())
})
},
)?;
let p2pk33addressindex_to_p2pk33addressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2pk33addressindex",
version + VERSION + Version::ZERO,
format,
@@ -190,7 +194,7 @@ impl Vecs {
)?;
let p2pk65addressindex_to_p2pk65addressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2pk65addressindex",
version + VERSION + Version::ZERO,
format,
@@ -199,7 +203,7 @@ impl Vecs {
)?;
let p2pkhaddressindex_to_p2pkhaddressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2pkhaddressindex",
version + VERSION + Version::ZERO,
format,
@@ -208,7 +212,7 @@ impl Vecs {
)?;
let p2shaddressindex_to_p2shaddressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2shaddressindex",
version + VERSION + Version::ZERO,
format,
@@ -217,7 +221,7 @@ impl Vecs {
)?;
let p2traddressindex_to_p2traddressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2traddressindex",
version + VERSION + Version::ZERO,
format,
@@ -226,7 +230,7 @@ impl Vecs {
)?;
let p2wpkhaddressindex_to_p2wpkhaddressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2wpkhaddressindex",
version + VERSION + Version::ZERO,
format,
@@ -235,7 +239,7 @@ impl Vecs {
)?;
let p2wshaddressindex_to_p2wshaddressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2wshaddressindex",
version + VERSION + Version::ZERO,
format,
@@ -244,7 +248,7 @@ impl Vecs {
)?;
let p2aaddressindex_to_p2aaddressindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2aaddressindex",
version + VERSION + Version::ZERO,
format,
@@ -253,7 +257,7 @@ impl Vecs {
)?;
let p2msoutputindex_to_p2msoutputindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"p2msoutputindex",
version + VERSION + Version::ZERO,
format,
@@ -262,7 +266,7 @@ impl Vecs {
)?;
let emptyoutputindex_to_emptyoutputindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"emptyoutputindex",
version + VERSION + Version::ZERO,
format,
@@ -271,7 +275,7 @@ impl Vecs {
)?;
let unknownoutputindex_to_unknownoutputindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"unknownoutputindex",
version + VERSION + Version::ZERO,
format,
@@ -280,7 +284,7 @@ impl Vecs {
)?;
let opreturnindex_to_opreturnindex = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"opreturnindex",
version + VERSION + Version::ZERO,
format,
@@ -308,263 +312,265 @@ impl Vecs {
unknownoutputindex_to_unknownoutputindex,
dateindex_to_date: EagerVec::forced_import(
file,
&file,
"date",
version + VERSION + Version::ZERO,
format,
)?,
dateindex_to_dateindex: EagerVec::forced_import(
file,
&file,
"dateindex",
version + VERSION + Version::ZERO,
format,
)?,
dateindex_to_first_height: EagerVec::forced_import(
file,
&file,
"first_height",
version + VERSION + Version::ZERO,
format,
)?,
dateindex_to_monthindex: EagerVec::forced_import(
file,
&file,
"monthindex",
version + VERSION + Version::ZERO,
format,
)?,
dateindex_to_weekindex: EagerVec::forced_import(
file,
&file,
"weekindex",
version + VERSION + Version::ZERO,
format,
)?,
decadeindex_to_decadeindex: EagerVec::forced_import(
file,
&file,
"decadeindex",
version + VERSION + Version::ZERO,
format,
)?,
decadeindex_to_first_yearindex: EagerVec::forced_import(
file,
&file,
"first_yearindex",
version + VERSION + Version::ZERO,
format,
)?,
difficultyepoch_to_difficultyepoch: EagerVec::forced_import(
file,
&file,
"difficultyepoch",
version + VERSION + Version::ZERO,
format,
)?,
difficultyepoch_to_first_height: EagerVec::forced_import(
file,
&file,
"first_height",
version + VERSION + Version::ZERO,
format,
)?,
halvingepoch_to_first_height: EagerVec::forced_import(
file,
&file,
"first_height",
version + VERSION + Version::ZERO,
format,
)?,
halvingepoch_to_halvingepoch: EagerVec::forced_import(
file,
&file,
"halvingepoch",
version + VERSION + Version::ZERO,
format,
)?,
height_to_date: EagerVec::forced_import(
file,
&file,
"date",
version + VERSION + Version::ZERO,
format,
)?,
height_to_difficultyepoch: EagerVec::forced_import(
file,
&file,
"difficultyepoch",
version + VERSION + Version::ZERO,
format,
)?,
height_to_halvingepoch: EagerVec::forced_import(
file,
&file,
"halvingepoch",
version + VERSION + Version::ZERO,
format,
)?,
height_to_height: EagerVec::forced_import(
file,
&file,
"height",
version + VERSION + Version::ZERO,
format,
)?,
monthindex_to_first_dateindex: EagerVec::forced_import(
file,
&file,
"first_dateindex",
version + VERSION + Version::ZERO,
format,
)?,
monthindex_to_monthindex: EagerVec::forced_import(
file,
&file,
"monthindex",
version + VERSION + Version::ZERO,
format,
)?,
monthindex_to_quarterindex: EagerVec::forced_import(
file,
&file,
"quarterindex",
version + VERSION + Version::ZERO,
format,
)?,
monthindex_to_semesterindex: EagerVec::forced_import(
file,
&file,
"semesterindex",
version + VERSION + Version::ZERO,
format,
)?,
monthindex_to_yearindex: EagerVec::forced_import(
file,
&file,
"yearindex",
version + VERSION + Version::ZERO,
format,
)?,
quarterindex_to_first_monthindex: EagerVec::forced_import(
file,
&file,
"first_monthindex",
version + VERSION + Version::ZERO,
format,
)?,
semesterindex_to_first_monthindex: EagerVec::forced_import(
file,
&file,
"first_monthindex",
version + VERSION + Version::ZERO,
format,
)?,
weekindex_to_first_dateindex: EagerVec::forced_import(
file,
&file,
"first_dateindex",
version + VERSION + Version::ZERO,
format,
)?,
yearindex_to_first_monthindex: EagerVec::forced_import(
file,
&file,
"first_monthindex",
version + VERSION + Version::ZERO,
format,
)?,
quarterindex_to_quarterindex: EagerVec::forced_import(
file,
&file,
"quarterindex",
version + VERSION + Version::ZERO,
format,
)?,
semesterindex_to_semesterindex: EagerVec::forced_import(
file,
&file,
"semesterindex",
version + VERSION + Version::ZERO,
format,
)?,
weekindex_to_weekindex: EagerVec::forced_import(
file,
&file,
"weekindex",
version + VERSION + Version::ZERO,
format,
)?,
yearindex_to_decadeindex: EagerVec::forced_import(
file,
&file,
"decadeindex",
version + VERSION + Version::ZERO,
format,
)?,
yearindex_to_yearindex: EagerVec::forced_import(
file,
&file,
"yearindex",
version + VERSION + Version::ZERO,
format,
)?,
height_to_date_fixed: EagerVec::forced_import(
file,
&file,
"date_fixed",
version + VERSION + Version::ZERO,
format,
)?,
height_to_dateindex: EagerVec::forced_import(
file,
&file,
"dateindex",
version + VERSION + Version::ZERO,
format,
)?,
txindex_to_height: EagerVec::forced_import(
file,
&file,
"height",
version + VERSION + Version::ZERO,
format,
)?,
height_to_timestamp_fixed: EagerVec::forced_import(
file,
&file,
"timestamp_fixed",
version + VERSION + Version::ZERO,
format,
)?,
height_to_txindex_count: EagerVec::forced_import(
file,
&file,
"txindex_count",
version + VERSION + Version::ZERO,
format,
)?,
dateindex_to_height_count: EagerVec::forced_import(
file,
&file,
"height_count",
version + VERSION + Version::ZERO,
format,
)?,
weekindex_to_dateindex_count: EagerVec::forced_import(
file,
&file,
"dateindex_count",
version + VERSION + Version::ZERO,
format,
)?,
difficultyepoch_to_height_count: EagerVec::forced_import(
file,
&file,
"height_count",
version + VERSION + Version::ZERO,
format,
)?,
monthindex_to_dateindex_count: EagerVec::forced_import(
file,
&file,
"dateindex_count",
version + VERSION + Version::ZERO,
format,
)?,
quarterindex_to_monthindex_count: EagerVec::forced_import(
file,
&file,
"monthindex_count",
version + VERSION + Version::ZERO,
format,
)?,
semesterindex_to_monthindex_count: EagerVec::forced_import(
file,
&file,
"monthindex_count",
version + VERSION + Version::ZERO,
format,
)?,
yearindex_to_monthindex_count: EagerVec::forced_import(
file,
&file,
"monthindex_count",
version + VERSION + Version::ZERO,
format,
)?,
decadeindex_to_yearindex_count: EagerVec::forced_import(
file,
&file,
"yearindex_count",
version + VERSION + Version::ZERO,
format,
)?,
outputindex_to_txindex: EagerVec::forced_import(
file,
&file,
"txindex",
version + VERSION + Version::ZERO,
format,
)?,
file,
})
}
@@ -573,7 +579,7 @@ impl Vecs {
indexer: &Indexer,
starting_indexes: brk_indexer::Indexes,
exit: &Exit,
) -> color_eyre::Result<Indexes> {
) -> Result<Indexes> {
// ---
// OutputIndex
// ---
@@ -1110,6 +1116,9 @@ impl Vecs {
exit,
)?;
self.file.flush()?;
self.file.punch_holes()?;
Ok(Indexes {
indexes: starting_indexes,
dateindex: starting_dateindex,

223
crates/brk_computer/src/lib.rs
View File

@@ -3,16 +3,15 @@
#![doc = include_str!("../examples/main.rs")]
#![doc = "```"]
use std::{path::Path, sync::Arc};
use std::path::Path;
use brk_core::Version;
use brk_exit::Exit;
use brk_error::Result;
use brk_fetcher::Fetcher;
use brk_indexer::Indexer;
use brk_vecs::{Computation, File, Format, PAGE_SIZE};
use brk_structs::Version;
use brk_vecs::{AnyCollectableVec, Computation, Exit, Format};
use log::info;
mod all;
mod blocks;
mod cointime;
mod constants;
@@ -21,8 +20,10 @@ mod grouped;
mod indexes;
mod market;
mod mining;
mod price;
mod stateful;
mod states;
mod traits;
mod transactions;
mod utils;
@@ -32,9 +33,16 @@ use states::*;
#[derive(Clone)]
pub struct Computer {
file: Arc<File>,
fetcher: Option<Fetcher>,
pub vecs: all::Vecs,
pub indexes: indexes::Vecs,
pub constants: constants::Vecs,
pub blocks: blocks::Vecs,
pub mining: mining::Vecs,
pub market: market::Vecs,
pub price: Option<price::Vecs>,
pub transactions: transactions::Vecs,
pub stateful: stateful::Vecs,
pub fetched: Option<fetched::Vecs>,
pub cointime: cointime::Vecs,
}
const VERSION: Version = Version::ONE;
@@ -42,50 +50,193 @@ const VERSION: Version = Version::ONE;
impl Computer {
/// Do NOT import multiple times or things will break !!!
pub fn forced_import(
outputs_dir: &Path,
outputs_path: &Path,
indexer: &Indexer,
computation: Computation,
fetcher: Option<Fetcher>,
format: Format,
) -> color_eyre::Result<Self> {
let computed_path = outputs_dir.join("computed");
let states_path = computed_path.join("states");
) -> Result<Self> {
let computed_path = outputs_path.join("computed");
let file = Arc::new(File::open(&computed_path.join("vecs"))?);
file.set_min_len(PAGE_SIZE * 100_000_000)?;
file.set_min_regions(50_000)?;
let computation = Computation::Lazy;
let format = Format::Compressed;
let file_fetched = Arc::new(File::open(&outputs_dir.join("fetched/vecs"))?);
let indexes = indexes::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
indexer,
computation,
format,
)?;
Ok(Self {
vecs: all::Vecs::import(
&file,
let fetched = fetcher.map(|fetcher| {
fetched::Vecs::forced_import(outputs_path, fetcher, VERSION + Version::ZERO).unwrap()
});
let price = fetched.is_some().then(|| {
price::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
indexer,
fetcher.is_some(),
computation,
format,
&file_fetched,
&states_path,
&indexes,
)
.unwrap()
});
Ok(Self {
blocks: blocks::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
computation,
format,
&indexes,
)?,
fetcher,
file,
mining: mining::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
computation,
format,
&indexes,
)?,
constants: constants::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
computation,
format,
&indexes,
)?,
market: market::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
computation,
format,
&indexes,
)?,
stateful: stateful::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
computation,
format,
&indexes,
price.as_ref(),
&computed_path.join("states"),
)?,
transactions: transactions::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
indexer,
&indexes,
computation,
format,
price.as_ref(),
)?,
cointime: cointime::Vecs::forced_import(
&computed_path,
VERSION + Version::ZERO,
computation,
format,
&indexes,
price.as_ref(),
)?,
indexes,
fetched,
price,
})
}
}
impl Computer {
pub fn compute(
&mut self,
indexer: &mut Indexer,
indexer: &Indexer,
starting_indexes: brk_indexer::Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
info!("Computing...");
self.vecs
.compute(indexer, starting_indexes, self.fetcher.as_mut(), exit)?;
self.file.flush()?;
self.file.punch_holes()?;
) -> Result<()> {
info!("Computing indexes...");
let mut starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
info!("Computing constants...");
self.constants
.compute(indexer, &self.indexes, &starting_indexes, exit)?;
info!("Computing blocks...");
self.blocks
.compute(indexer, &self.indexes, &starting_indexes, exit)?;
info!("Computing mining...");
self.mining
.compute(indexer, &self.indexes, &starting_indexes, exit)?;
if let Some(fetched) = self.fetched.as_mut() {
info!("Computing fetched...");
fetched.compute(indexer, &self.indexes, &starting_indexes, exit)?;
self.price.as_mut().unwrap().compute(
indexer,
&self.indexes,
&starting_indexes,
fetched,
exit,
)?;
}
info!("Computing transactions...");
self.transactions.compute(
indexer,
&self.indexes,
&starting_indexes,
self.price.as_ref(),
exit,
)?;
if let Some(price) = self.price.as_ref() {
info!("Computing market...");
self.market.compute(
indexer,
&self.indexes,
price,
&mut self.transactions,
&starting_indexes,
exit,
)?;
}
info!("Computing stateful...");
self.stateful.compute(
indexer,
&self.indexes,
&self.transactions,
self.price.as_ref(),
&self.market,
&mut starting_indexes,
exit,
)?;
self.cointime.compute(
indexer,
&self.indexes,
&starting_indexes,
self.price.as_ref(),
&self.transactions,
&self.stateful,
exit,
)?;
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.constants.vecs(),
self.indexes.vecs(),
self.blocks.vecs(),
self.mining.vecs(),
self.market.vecs(),
self.transactions.vecs(),
self.stateful.vecs(),
self.cointime.vecs(),
self.fetched.as_ref().map_or(vec![], |v| v.vecs()),
self.price.as_ref().map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
}
}

493
crates/brk_computer/src/market.rs
View File

File diff suppressed because it is too large Load Diff

34
crates/brk_computer/src/mining.rs
View File

@@ -1,9 +1,9 @@
use std::sync::Arc;
use std::{path::Path, sync::Arc};
use brk_core::{DifficultyEpoch, HalvingEpoch, StoredF64, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, Computation, File, Format, VecIterator};
use brk_structs::{DifficultyEpoch, HalvingEpoch, StoredF64, Version};
use brk_vecs::{AnyCollectableVec, Computation, Exit, File, Format, VecIterator};
use crate::grouped::Source;
@@ -17,6 +17,8 @@ const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
file: Arc<File>,
pub indexes_to_difficulty: ComputedVecsFromHeight<StoredF64>,
pub indexes_to_difficultyepoch: ComputedVecsFromDateIndex<DifficultyEpoch>,
pub indexes_to_halvingepoch: ComputedVecsFromDateIndex<HalvingEpoch>,
@@ -24,15 +26,17 @@ pub struct Vecs {
impl Vecs {
pub fn forced_import(
file: &Arc<File>,
parent: &Path,
version: Version,
computation: Computation,
format: Format,
indexes: &indexes::Vecs,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
let file = Arc::new(File::open(&parent.join("mining"))?);
Ok(Self {
indexes_to_difficulty: ComputedVecsFromHeight::forced_import(
file,
&file,
"difficulty",
Source::None,
version + VERSION + Version::ZERO,
@@ -42,7 +46,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_difficultyepoch: ComputedVecsFromDateIndex::forced_import(
file,
&file,
"difficultyepoch",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -52,7 +56,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_halvingepoch: ComputedVecsFromDateIndex::forced_import(
file,
&file,
"halvingepoch",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -61,6 +65,8 @@ impl Vecs {
indexes,
VecBuilderOptions::default().add_last(),
)?,
file,
})
}
@@ -70,7 +76,7 @@ impl Vecs {
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
let mut height_to_difficultyepoch_iter = indexes.height_to_difficultyepoch.into_iter();
self.indexes_to_difficultyepoch.compute_all(
indexer,
@@ -91,7 +97,8 @@ impl Vecs {
)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -115,7 +122,8 @@ impl Vecs {
)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -126,6 +134,8 @@ impl Vecs {
Some(&indexer.vecs.height_to_difficulty),
)?;
self.file.flush()?;
self.file.punch_holes()?;
Ok(())
}

1273
crates/brk_computer/src/price.rs Normal file
View File

File diff suppressed because it is too large Load Diff

35
crates/brk_computer/src/stateful/address_cohort.rs
View File

@@ -1,16 +1,17 @@
use std::{ops::Deref, path::Path, sync::Arc};
use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, StoredUsize, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, AnyVec, Computation, EagerVec, File, Format, VecIterator,
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Computation, EagerVec, Exit, File,
Format, GenericStoredVec, VecIterator,
};
use crate::{
Indexes, fetched,
Indexes,
grouped::{ComputedVecsFromHeight, Source, VecBuilderOptions},
indexes, market,
indexes, market, price,
stateful::{
common,
r#trait::{CohortVecs, DynCohortVecs},
@@ -28,8 +29,8 @@ pub struct Vecs {
pub inner: common::Vecs,
pub height_to_address_count: EagerVec<Height, StoredUsize>,
pub indexes_to_address_count: ComputedVecsFromHeight<StoredUsize>,
pub height_to_address_count: EagerVec<Height, StoredU64>,
pub indexes_to_address_count: ComputedVecsFromHeight<StoredU64>,
}
impl Vecs {
@@ -41,11 +42,11 @@ impl Vecs {
format: Format,
version: Version,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
states_path: &Path,
compute_relative_to_all: bool,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
) -> Result<Self> {
let compute_dollars = price.is_some();
let suffix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{name}_{s}"));
@@ -79,7 +80,7 @@ impl Vecs {
format,
version,
indexes,
fetched,
price,
compute_relative_to_all,
false,
)?,
@@ -170,10 +171,10 @@ impl DynCohortVecs for Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.indexes_to_address_count.compute_rest(
indexes,
starting_indexes,
@@ -182,7 +183,7 @@ impl DynCohortVecs for Vecs {
)?;
self.inner
.compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)
}
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
@@ -223,7 +224,7 @@ impl CohortVecs for Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
@@ -231,11 +232,11 @@ impl CohortVecs for Vecs {
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.inner.compute_rest_part2(
indexer,
indexes,
fetched,
price,
starting_indexes,
market,
height_to_supply,

112
crates/brk_computer/src/stateful/address_cohorts.rs
View File

@@ -1,16 +1,16 @@
use std::{path::Path, sync::Arc};
use brk_core::{
AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex,
Dollars, GroupFilter, Height, Result, Version,
};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyIterableVec, Computation, File, Format};
use brk_structs::{
AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex,
Dollars, GroupFilter, Height, Version,
};
use brk_vecs::{AnyIterableVec, Computation, Exit, File, Format};
use derive_deref::{Deref, DerefMut};
use crate::{
Indexes, fetched, indexes, market,
Indexes, indexes, market, price,
stateful::{
address_cohort,
r#trait::{CohortVecs, DynCohortVecs},
@@ -29,9 +29,9 @@ impl Vecs {
_computation: Computation,
format: Format,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
states_path: &Path,
) -> color_eyre::Result<Self> {
) -> Result<Self> {
Ok(Self(
AddressGroups {
amount_range: ByAmountRange {
@@ -42,7 +42,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -53,7 +53,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -64,7 +64,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -75,7 +75,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -86,7 +86,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -97,7 +97,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -108,7 +108,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -119,7 +119,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -130,7 +130,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -141,7 +141,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -152,7 +152,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -163,7 +163,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -174,7 +174,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -185,7 +185,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -196,7 +196,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -209,7 +209,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -220,7 +220,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -231,7 +231,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -242,7 +242,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -253,7 +253,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -264,7 +264,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -275,7 +275,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -286,7 +286,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -297,7 +297,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -308,7 +308,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -319,7 +319,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -330,7 +330,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -341,7 +341,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -354,7 +354,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -365,7 +365,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -376,7 +376,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -387,7 +387,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -398,7 +398,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -409,7 +409,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -420,7 +420,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -431,7 +431,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -442,7 +442,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -453,7 +453,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -464,7 +464,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -475,7 +475,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -486,7 +486,7 @@ impl Vecs {
format,
version + VERSION + Version::ZERO,
indexes,
fetched,
price,
states_path,
true,
)?,
@@ -546,12 +546,12 @@ impl Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.as_mut_vecs().into_iter().try_for_each(|(_, v)| {
v.compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)
v.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)
})
}
@@ -560,7 +560,7 @@ impl Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
@@ -568,13 +568,13 @@ impl Vecs {
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| {
v.into_iter().try_for_each(|(_, v)| {
v.compute_rest_part2(
indexer,
indexes,
fetched,
price,
starting_indexes,
market,
height_to_supply,

4
crates/brk_computer/src/stateful/addresstype_to_addresscount.rs
View File

@@ -1,11 +1,11 @@
use brk_core::{ByAddressType, Height};
use brk_structs::{ByAddressType, Height};
use brk_vecs::VecIterator;
use derive_deref::{Deref, DerefMut};
use crate::stateful::addresstype_to_height_to_addresscount::AddressTypeToHeightToAddressCount;
#[derive(Debug, Default, Deref, DerefMut)]
pub struct AddressTypeToAddressCount(ByAddressType<usize>);
pub struct AddressTypeToAddressCount(ByAddressType<u64>);
impl From<(&AddressTypeToHeightToAddressCount, Height)> for AddressTypeToAddressCount {
fn from((groups, starting_height): (&AddressTypeToHeightToAddressCount, Height)) -> Self {

12
crates/brk_computer/src/stateful/addresstype_to_height_to_addresscount.rs
View File

@@ -1,15 +1,15 @@
use brk_core::{ByAddressType, Height, Result, StoredUsize};
use brk_exit::Exit;
use brk_vecs::EagerVec;
use brk_error::Result;
use brk_structs::{ByAddressType, Height, StoredU64};
use brk_vecs::{EagerVec, Exit, GenericStoredVec};
use derive_deref::{Deref, DerefMut};
use crate::stateful::addresstype_to_addresscount::AddressTypeToAddressCount;
#[derive(Debug, Clone, Deref, DerefMut)]
pub struct AddressTypeToHeightToAddressCount(ByAddressType<EagerVec<Height, StoredUsize>>);
pub struct AddressTypeToHeightToAddressCount(ByAddressType<EagerVec<Height, StoredU64>>);
impl From<ByAddressType<EagerVec<Height, StoredUsize>>> for AddressTypeToHeightToAddressCount {
fn from(value: ByAddressType<EagerVec<Height, StoredUsize>>) -> Self {
impl From<ByAddressType<EagerVec<Height, StoredU64>>> for AddressTypeToHeightToAddressCount {
fn from(value: ByAddressType<EagerVec<Height, StoredU64>>) -> Self {
Self(value)
}
}

16
crates/brk_computer/src/stateful/addresstype_to_indexes_to_addresscount.rs
View File

@@ -1,6 +1,6 @@
use brk_core::{ByAddressType, StoredUsize};
use brk_exit::Exit;
use brk_vecs::AnyCollectableVec;
use brk_error::Result;
use brk_structs::{ByAddressType, StoredU64};
use brk_vecs::{AnyCollectableVec, Exit};
use derive_deref::{Deref, DerefMut};
use crate::{
@@ -9,12 +9,10 @@ use crate::{
};
#[derive(Clone, Deref, DerefMut)]
pub struct AddressTypeToIndexesToAddressCount(ByAddressType<ComputedVecsFromHeight<StoredUsize>>);
pub struct AddressTypeToIndexesToAddressCount(ByAddressType<ComputedVecsFromHeight<StoredU64>>);
impl From<ByAddressType<ComputedVecsFromHeight<StoredUsize>>>
for AddressTypeToIndexesToAddressCount
{
fn from(value: ByAddressType<ComputedVecsFromHeight<StoredUsize>>) -> Self {
impl From<ByAddressType<ComputedVecsFromHeight<StoredU64>>> for AddressTypeToIndexesToAddressCount {
fn from(value: ByAddressType<ComputedVecsFromHeight<StoredU64>>) -> Self {
Self(value)
}
}
@@ -27,7 +25,7 @@ impl AddressTypeToIndexesToAddressCount {
starting_indexes: &Indexes,
exit: &Exit,
addresstype_to_height_to_addresscount: &AddressTypeToHeightToAddressCount,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.p2pk65.compute_rest(
indexes,
starting_indexes,

2
crates/brk_computer/src/stateful/addresstype_to_typeindex_set.rs
View File

@@ -1,6 +1,6 @@
use std::collections::BTreeSet;
use brk_core::TypeIndex;
use brk_structs::TypeIndex;
use derive_deref::{Deref, DerefMut};
use super::ByAddressType;

2
crates/brk_computer/src/stateful/addresstype_to_typeindex_tree.rs
View File

@@ -1,6 +1,6 @@
use std::{collections::BTreeMap, mem};
use brk_core::TypeIndex;
use brk_structs::TypeIndex;
use derive_deref::{Deref, DerefMut};
use super::ByAddressType;

138
crates/brk_computer/src/stateful/common.rs
View File

@@ -1,22 +1,22 @@
use std::sync::Arc;
use brk_core::{
Bitcoin, DateIndex, Dollars, Height, Result, Sats, StoredF32, StoredF64, StoredUsize, Version,
};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{
Bitcoin, DateIndex, Dollars, Height, Sats, StoredF32, StoredF64, StoredU64, Version,
};
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, AnyVec, CloneableAnyIterableVec, Computation, EagerVec,
File, Format, VecIterator,
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Computation,
EagerVec, Exit, File, Format, GenericStoredVec, VecIterator,
};
use crate::{
Indexes, fetched,
Indexes,
grouped::{
ComputedHeightValueVecs, ComputedRatioVecsFromDateIndex, ComputedValueVecsFromDateIndex,
ComputedVecsFromDateIndex, ComputedVecsFromHeight, Source, VecBuilderOptions,
},
indexes, market,
indexes, market, price,
states::CohortState,
};
@@ -27,7 +27,7 @@ pub struct Vecs {
// Cumulative
pub height_to_realized_cap: Option<EagerVec<Height, Dollars>>,
pub height_to_supply: EagerVec<Height, Sats>,
pub height_to_utxo_count: EagerVec<Height, StoredUsize>,
pub height_to_utxo_count: EagerVec<Height, StoredU64>,
// Single
pub dateindex_to_supply_even: Option<EagerVec<DateIndex, Sats>>,
pub dateindex_to_supply_in_loss: Option<EagerVec<DateIndex, Sats>>,
@@ -68,7 +68,7 @@ pub struct Vecs {
pub indexes_to_realized_value: Option<ComputedVecsFromHeight<Dollars>>,
pub height_to_supply_value: ComputedHeightValueVecs,
pub indexes_to_supply: ComputedValueVecsFromDateIndex,
pub indexes_to_utxo_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_utxo_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_value_created: Option<ComputedVecsFromHeight<Dollars>>,
pub indexes_to_value_destroyed: Option<ComputedVecsFromHeight<Dollars>>,
pub indexes_to_unrealized_profit: Option<ComputedVecsFromDateIndex<Dollars>>,
@@ -134,11 +134,11 @@ impl Vecs {
format: Format,
version: Version,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
compute_relative_to_all: bool,
ratio_extended: bool,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
) -> Result<Self> {
let compute_dollars = price.is_some();
// let prefix = |s: &str| cohort_name.map_or(s.to_string(), |name| format!("{s}_{name}"));
@@ -1368,7 +1368,7 @@ impl Vecs {
self.height_to_utxo_count.forced_push_at(
height,
StoredUsize::from(state.supply.utxos),
StoredU64::from(state.supply.utxos),
exit,
)?;
@@ -1899,12 +1899,12 @@ impl Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.height_to_supply_value.compute_rest(
fetched,
price,
starting_indexes,
exit,
Some(&self.height_to_supply),
@@ -1913,7 +1913,7 @@ impl Vecs {
self.indexes_to_supply.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|v, _, indexes, starting_indexes, exit| {
@@ -1925,14 +1925,15 @@ impl Vecs {
&indexes.dateindex_to_first_height,
|(i, height, ..)| {
let count = dateindex_to_height_count_iter.unwrap_get_inner(i);
if count == StoredUsize::default() {
if count == StoredU64::default() {
unreachable!()
}
let supply = height_to_supply_iter.unwrap_get_inner(height + (*count - 1));
(i, supply)
},
exit,
)
)?;
Ok(())
},
)?;
@@ -1946,7 +1947,7 @@ impl Vecs {
self.height_to_halved_supply_value.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
@@ -1955,14 +1956,15 @@ impl Vecs {
&self.height_to_supply,
|(h, v, ..)| (h, v / 2),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_halved_supply.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|v, _, _, starting_indexes, exit| {
@@ -1971,7 +1973,8 @@ impl Vecs {
self.indexes_to_supply.sats.dateindex.as_ref().unwrap(),
|(i, sats, ..)| (i, sats / 2),
exit,
)
)?;
Ok(())
},
)?;
@@ -1986,7 +1989,8 @@ impl Vecs {
&self.height_to_satblocks_destroyed,
|(i, v, ..)| (i, StoredF64::from(Bitcoin::from(v))),
exit,
)
)?;
Ok(())
},
)?;
@@ -2001,7 +2005,8 @@ impl Vecs {
&self.height_to_satdays_destroyed,
|(i, v, ..)| (i, StoredF64::from(Bitcoin::from(v))),
exit,
)
)?;
Ok(())
},
)?;
@@ -2013,7 +2018,7 @@ impl Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
@@ -2021,7 +2026,7 @@ impl Vecs {
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
if let Some(v) = self
.indexes_to_supply_relative_to_circulating_supply
.as_mut()
@@ -2037,7 +2042,8 @@ impl Vecs {
&self.height_to_supply_value.bitcoin,
height_to_supply,
exit,
)
)?;
Ok(())
},
)?;
}
@@ -2064,7 +2070,8 @@ impl Vecs {
self.height_to_realized_cap.as_ref().unwrap(),
&self.height_to_supply_value.bitcoin,
exit,
)
)?;
Ok(())
},
)?;
@@ -2074,7 +2081,7 @@ impl Vecs {
.compute_rest(
indexer,
indexes,
fetched.as_ref().unwrap(),
price.as_ref().unwrap(),
starting_indexes,
exit,
Some(
@@ -2120,7 +2127,8 @@ impl Vecs {
self.height_to_realized_loss.as_ref().unwrap(),
|(i, v, ..)| (i, v * -1_i64),
exit,
)
)?;
Ok(())
},
)?;
@@ -2182,7 +2190,8 @@ impl Vecs {
.unwrap_last(),
30,
exit,
)
)?;
Ok(())
},
)?;
@@ -2200,7 +2209,8 @@ impl Vecs {
self.height_to_realized_profit.as_ref().unwrap(),
self.height_to_realized_loss.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2218,7 +2228,8 @@ impl Vecs {
self.height_to_realized_profit.as_ref().unwrap(),
self.height_to_realized_loss.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2282,7 +2293,7 @@ impl Vecs {
.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(self.dateindex_to_supply_in_profit.as_ref().unwrap()),
@@ -2293,7 +2304,7 @@ impl Vecs {
.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(self.dateindex_to_supply_in_loss.as_ref().unwrap()),
@@ -2301,7 +2312,7 @@ impl Vecs {
self.indexes_to_supply_even.as_mut().unwrap().compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(self.dateindex_to_supply_even.as_ref().unwrap()),
@@ -2367,7 +2378,8 @@ impl Vecs {
self.dateindex_to_unrealized_loss.as_ref().unwrap(),
|(h, v, ..)| (h, v * -1_i64),
exit,
)
)?;
Ok(())
},
)?;
self.height_to_net_unrealized_profit_and_loss
@@ -2394,7 +2406,8 @@ impl Vecs {
self.dateindex_to_unrealized_profit.as_ref().unwrap(),
self.dateindex_to_unrealized_loss.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.height_to_net_unrealized_profit_and_loss_relative_to_market_cap
@@ -2427,7 +2440,8 @@ impl Vecs {
.unwrap(),
market.indexes_to_marketcap.dateindex.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2445,7 +2459,8 @@ impl Vecs {
self.height_to_realized_profit.as_ref().unwrap(),
*height_to_realized_cap.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2463,7 +2478,8 @@ impl Vecs {
self.height_to_realized_loss.as_ref().unwrap(),
*height_to_realized_cap.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2486,7 +2502,8 @@ impl Vecs {
.unwrap(),
*height_to_realized_cap.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2494,7 +2511,7 @@ impl Vecs {
.as_mut()
.unwrap()
.compute_rest(
fetched,
price,
starting_indexes,
exit,
Some(self.height_to_supply_even.as_ref().unwrap()),
@@ -2503,7 +2520,7 @@ impl Vecs {
.as_mut()
.unwrap()
.compute_rest(
fetched,
price,
starting_indexes,
exit,
Some(self.height_to_supply_in_loss.as_ref().unwrap()),
@@ -2512,7 +2529,7 @@ impl Vecs {
.as_mut()
.unwrap()
.compute_rest(
fetched,
price,
starting_indexes,
exit,
Some(self.height_to_supply_in_profit.as_ref().unwrap()),
@@ -2572,7 +2589,8 @@ impl Vecs {
.unwrap(),
self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_supply_in_loss_relative_to_own_supply
@@ -2595,7 +2613,8 @@ impl Vecs {
.unwrap(),
self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_supply_in_profit_relative_to_own_supply
@@ -2618,7 +2637,8 @@ impl Vecs {
.unwrap(),
self.indexes_to_supply.bitcoin.dateindex.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2640,7 +2660,8 @@ impl Vecs {
.unwrap_cumulative(),
30,
exit,
)
)?;
Ok(())
},
)?;
@@ -2658,7 +2679,8 @@ impl Vecs {
self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change.as_ref().unwrap().dateindex.as_ref().unwrap(),
*dateindex_to_realized_cap.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2676,7 +2698,8 @@ impl Vecs {
self.indexes_to_net_realized_profit_and_loss_cumulative_30d_change.as_ref().unwrap().dateindex.as_ref().unwrap(),
market.indexes_to_marketcap.dateindex.as_ref().unwrap(),
exit,
)
)?;
Ok(())
},
)?;
@@ -2736,7 +2759,8 @@ impl Vecs {
.unwrap(),
dateindex_to_supply,
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_supply_in_loss_relative_to_circulating_supply
@@ -2759,7 +2783,8 @@ impl Vecs {
.unwrap(),
dateindex_to_supply,
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_supply_in_profit_relative_to_circulating_supply
@@ -2782,7 +2807,8 @@ impl Vecs {
.unwrap(),
dateindex_to_supply,
exit,
)
)?;
Ok(())
},
)?;
}

2
crates/brk_computer/src/stateful/height_to_addresstype_to_vec.rs
View File

@@ -1,6 +1,6 @@
use std::collections::BTreeMap;
use brk_core::Height;
use brk_structs::Height;
use derive_deref::{Deref, DerefMut};
use crate::stateful::AddressTypeToVec;

368
crates/brk_computer/src/stateful/mod.rs
View File

@@ -1,31 +1,26 @@
use std::{cmp::Ordering, collections::BTreeMap, mem, path::Path, sync::Arc, thread};
use brk_core::{
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{
AnyAddressDataIndexEnum, AnyAddressIndex, ByAddressType, ByAnyAddress, CheckedSub, DateIndex,
Dollars, EmptyAddressData, EmptyAddressIndex, Height, InputIndex, LoadedAddressData,
LoadedAddressIndex, OutputIndex, OutputType, P2AAddressIndex, P2PK33AddressIndex,
P2PK65AddressIndex, P2PKHAddressIndex, P2SHAddressIndex, P2TRAddressIndex, P2WPKHAddressIndex,
P2WSHAddressIndex, Result, Sats, StoredUsize, Timestamp, TypeIndex, Version,
P2WSHAddressIndex, Sats, StoredU64, Timestamp, TypeIndex, Version,
};
use brk_exit::Exit;
use brk_indexer::Indexer;
use brk_vecs::{
AnyCollectableVec, AnyStampedVec, AnyVec, CollectableVec, Computation, EagerVec, File, Format,
GenericStoredVec, Reader, Stamp, StampedVec, StoredIndex, StoredVec, VecIterator,
AnyCollectableVec, AnyStoredVec, AnyVec, CollectableVec, Computation, EagerVec, Exit, File,
Format, GenericStoredVec, RawVec, Reader, Stamp, StoredIndex, VecIterator,
};
use log::info;
use rayon::prelude::*;
use crate::{
BlockState, SupplyState, Transacted,
grouped::{ComputedVecsFromHeight, Source},
market,
};
use super::{
Indexes, fetched,
BlockState, Indexes, SupplyState, Transacted,
grouped::{ComputedValueVecsFromHeight, VecBuilderOptions},
indexes, transactions,
grouped::{ComputedVecsFromHeight, Source},
indexes, market, price, transactions,
};
mod address_cohort;
@@ -58,7 +53,9 @@ const VERSION: Version = Version::new(21);
#[derive(Clone)]
pub struct Vecs {
pub chain_state: StoredVec<Height, SupplyState>,
file: Arc<File>,
pub chain_state: RawVec<Height, SupplyState>,
pub height_to_unspendable_supply: EagerVec<Height, Sats>,
pub indexes_to_unspendable_supply: ComputedValueVecsFromHeight,
@@ -71,51 +68,52 @@ pub struct Vecs {
pub utxo_cohorts: utxo_cohorts::Vecs,
pub address_cohorts: address_cohorts::Vecs,
pub p2pk33addressindex_to_anyaddressindex: StampedVec<P2PK33AddressIndex, AnyAddressIndex>,
pub p2pk65addressindex_to_anyaddressindex: StampedVec<P2PK65AddressIndex, AnyAddressIndex>,
pub p2pkhaddressindex_to_anyaddressindex: StampedVec<P2PKHAddressIndex, AnyAddressIndex>,
pub p2shaddressindex_to_anyaddressindex: StampedVec<P2SHAddressIndex, AnyAddressIndex>,
pub p2traddressindex_to_anyaddressindex: StampedVec<P2TRAddressIndex, AnyAddressIndex>,
pub p2wpkhaddressindex_to_anyaddressindex: StampedVec<P2WPKHAddressIndex, AnyAddressIndex>,
pub p2wshaddressindex_to_anyaddressindex: StampedVec<P2WSHAddressIndex, AnyAddressIndex>,
pub p2aaddressindex_to_anyaddressindex: StampedVec<P2AAddressIndex, AnyAddressIndex>,
pub loadedaddressindex_to_loadedaddressdata: StampedVec<LoadedAddressIndex, LoadedAddressData>,
pub emptyaddressindex_to_emptyaddressdata: StampedVec<EmptyAddressIndex, EmptyAddressData>,
pub p2pk33addressindex_to_anyaddressindex: RawVec<P2PK33AddressIndex, AnyAddressIndex>,
pub p2pk65addressindex_to_anyaddressindex: RawVec<P2PK65AddressIndex, AnyAddressIndex>,
pub p2pkhaddressindex_to_anyaddressindex: RawVec<P2PKHAddressIndex, AnyAddressIndex>,
pub p2shaddressindex_to_anyaddressindex: RawVec<P2SHAddressIndex, AnyAddressIndex>,
pub p2traddressindex_to_anyaddressindex: RawVec<P2TRAddressIndex, AnyAddressIndex>,
pub p2wpkhaddressindex_to_anyaddressindex: RawVec<P2WPKHAddressIndex, AnyAddressIndex>,
pub p2wshaddressindex_to_anyaddressindex: RawVec<P2WSHAddressIndex, AnyAddressIndex>,
pub p2aaddressindex_to_anyaddressindex: RawVec<P2AAddressIndex, AnyAddressIndex>,
pub loadedaddressindex_to_loadedaddressdata: RawVec<LoadedAddressIndex, LoadedAddressData>,
pub emptyaddressindex_to_emptyaddressdata: RawVec<EmptyAddressIndex, EmptyAddressData>,
pub indexes_to_address_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_empty_address_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_address_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_empty_address_count: ComputedVecsFromHeight<StoredU64>,
}
impl Vecs {
pub fn forced_import(
file: &Arc<File>,
parent: &Path,
version: Version,
computation: Computation,
format: Format,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
states_path: &Path,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
) -> Result<Self> {
let file = Arc::new(File::open(&parent.join("stateful"))?);
let chain_file = Arc::new(File::open(&states_path.join("chain"))?);
let compute_dollars = price.is_some();
let chain_file = Arc::new(File::open(&parent.join("chain"))?);
Ok(Self {
chain_state: StoredVec::forced_import(
chain_state: RawVec::forced_import(
&chain_file,
"chain",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
height_to_unspendable_supply: EagerVec::forced_import(
file,
&file,
"unspendable_supply",
version + VERSION + Version::ZERO,
format,
)?,
indexes_to_unspendable_supply: ComputedValueVecsFromHeight::forced_import(
file,
&file,
"unspendable_supply",
Source::None,
version + VERSION + Version::ZERO,
@@ -126,13 +124,13 @@ impl Vecs {
indexes,
)?,
height_to_opreturn_supply: EagerVec::forced_import(
file,
&file,
"opreturn_supply",
version + VERSION + Version::ZERO,
format,
)?,
indexes_to_opreturn_supply: ComputedValueVecsFromHeight::forced_import(
file,
&file,
"opreturn_supply",
Source::None,
version + VERSION + Version::ZERO,
@@ -143,7 +141,7 @@ impl Vecs {
indexes,
)?,
indexes_to_address_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"address_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -153,7 +151,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
indexes_to_empty_address_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"empty_address_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -165,49 +163,49 @@ impl Vecs {
addresstype_to_height_to_address_count: AddressTypeToHeightToAddressCount::from(
ByAddressType {
p2pk65: EagerVec::forced_import(
file,
&file,
"p2pk65_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2pk33: EagerVec::forced_import(
file,
&file,
"p2pk33_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2pkh: EagerVec::forced_import(
file,
&file,
"p2pkh_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2sh: EagerVec::forced_import(
file,
&file,
"p2sh_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2wpkh: EagerVec::forced_import(
file,
&file,
"p2wpkh_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2wsh: EagerVec::forced_import(
file,
&file,
"p2wsh_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2tr: EagerVec::forced_import(
file,
&file,
"p2tr_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2a: EagerVec::forced_import(
file,
&file,
"p2a_address_count",
version + VERSION + Version::ZERO,
format,
@@ -217,49 +215,49 @@ impl Vecs {
addresstype_to_height_to_empty_address_count: AddressTypeToHeightToAddressCount::from(
ByAddressType {
p2pk65: EagerVec::forced_import(
file,
&file,
"p2pk65_empty_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2pk33: EagerVec::forced_import(
file,
&file,
"p2pk33_empty_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2pkh: EagerVec::forced_import(
file,
&file,
"p2pkh_empty_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2sh: EagerVec::forced_import(
file,
&file,
"p2sh_empty_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2wpkh: EagerVec::forced_import(
file,
&file,
"p2wpkh_empty_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2wsh: EagerVec::forced_import(
file,
&file,
"p2wsh_empty_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2tr: EagerVec::forced_import(
file,
&file,
"p2tr_empty_address_count",
version + VERSION + Version::ZERO,
format,
)?,
p2a: EagerVec::forced_import(
file,
&file,
"p2a_empty_address_count",
version + VERSION + Version::ZERO,
format,
@@ -269,7 +267,7 @@ impl Vecs {
addresstype_to_indexes_to_address_count: AddressTypeToIndexesToAddressCount::from(
ByAddressType {
p2pk65: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pk65_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -279,7 +277,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2pk33: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pk33_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -289,7 +287,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2pkh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pkh_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -299,7 +297,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2sh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2sh_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -309,7 +307,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2wpkh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2wpkh_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -319,7 +317,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2wsh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2wsh_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -329,7 +327,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2tr: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2tr_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -339,7 +337,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2a: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2a_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -353,7 +351,7 @@ impl Vecs {
addresstype_to_indexes_to_empty_address_count: AddressTypeToIndexesToAddressCount::from(
ByAddressType {
p2pk65: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pk65_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -363,7 +361,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2pk33: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pk33_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -373,7 +371,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2pkh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pkh_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -383,7 +381,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2sh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2sh_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -393,7 +391,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2wpkh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2wpkh_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -403,7 +401,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2wsh: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2wsh_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -413,7 +411,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2tr: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2tr_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -423,7 +421,7 @@ impl Vecs {
VecBuilderOptions::default().add_last(),
)?,
p2a: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2a_empty_address_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -435,85 +433,77 @@ impl Vecs {
},
),
utxo_cohorts: utxo_cohorts::Vecs::forced_import(
file,
&file,
version,
computation,
format,
indexes,
fetched,
price,
states_path,
)?,
address_cohorts: address_cohorts::Vecs::forced_import(
file,
&file,
version,
computation,
format,
indexes,
fetched,
price,
states_path,
)?,
p2aaddressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2aaddressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
p2pk33addressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2pk33addressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
p2pk65addressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2pk65addressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
p2pkhaddressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2pkhaddressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
p2shaddressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2shaddressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
p2traddressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2traddressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
p2wpkhaddressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2wpkhaddressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
p2wshaddressindex_to_anyaddressindex: StampedVec::forced_import(
file,
p2wshaddressindex_to_anyaddressindex: RawVec::forced_import(
&file,
"anyaddressindex",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
loadedaddressindex_to_loadedaddressdata: StampedVec::forced_import(
file,
loadedaddressindex_to_loadedaddressdata: RawVec::forced_import(
&file,
"loadedaddressdata",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
emptyaddressindex_to_emptyaddressdata: StampedVec::forced_import(
file,
emptyaddressindex_to_emptyaddressdata: RawVec::forced_import(
&file,
"emptyaddressdata",
version + VERSION + Version::ZERO,
Format::Raw,
)?,
file,
})
}
@@ -523,12 +513,12 @@ impl Vecs {
indexer: &Indexer,
indexes: &indexes::Vecs,
transactions: &transactions::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
market: &market::Vecs,
// Must take ownership as its indexes will be updated for this specific function
starting_indexes: &mut Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
let height_to_first_outputindex = &indexer.vecs.height_to_first_outputindex;
let height_to_first_inputindex = &indexer.vecs.height_to_first_inputindex;
let height_to_first_p2aaddressindex = &indexer.vecs.height_to_first_p2aaddressindex;
@@ -554,12 +544,12 @@ impl Vecs {
.height
.as_ref()
.unwrap();
let height_to_close = fetched
let height_to_close = price
.as_ref()
.map(|fetched| &fetched.chainindexes_to_close.height);
let dateindex_to_close = fetched
.map(|price| &price.chainindexes_to_close.height);
let dateindex_to_close = price
.as_ref()
.map(|fetched| fetched.timeindexes_to_close.dateindex.as_ref().unwrap());
.map(|price| price.timeindexes_to_close.dateindex.as_ref().unwrap());
let height_to_date_fixed = &indexes.height_to_date_fixed;
let dateindex_to_first_height = &indexes.dateindex_to_first_height;
let dateindex_to_height_count = &indexes.dateindex_to_height_count;
@@ -632,56 +622,16 @@ impl Vecs {
.unwrap_or_default(),
)
.min(chain_state_starting_height)
.min(
Height::from(u64::from(
self.p2pk33addressindex_to_anyaddressindex.stamp(),
))
.incremented(),
)
.min(
Height::from(u64::from(
self.p2pk65addressindex_to_anyaddressindex.stamp(),
))
.incremented(),
)
.min(
Height::from(u64::from(self.p2pkhaddressindex_to_anyaddressindex.stamp()))
.incremented(),
)
.min(
Height::from(u64::from(self.p2shaddressindex_to_anyaddressindex.stamp()))
.incremented(),
)
.min(
Height::from(u64::from(self.p2traddressindex_to_anyaddressindex.stamp()))
.incremented(),
)
.min(
Height::from(u64::from(
self.p2wpkhaddressindex_to_anyaddressindex.stamp(),
))
.incremented(),
)
.min(
Height::from(u64::from(self.p2wshaddressindex_to_anyaddressindex.stamp()))
.incremented(),
)
.min(
Height::from(u64::from(self.p2aaddressindex_to_anyaddressindex.stamp()))
.incremented(),
)
.min(
Height::from(u64::from(
self.loadedaddressindex_to_loadedaddressdata.stamp(),
))
.incremented(),
)
.min(
Height::from(u64::from(
self.emptyaddressindex_to_emptyaddressdata.stamp(),
))
.incremented(),
)
.min(Height::from(self.p2pk33addressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.p2pk65addressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.p2pkhaddressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.p2shaddressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.p2traddressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.p2wpkhaddressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.p2wshaddressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.p2aaddressindex_to_anyaddressindex.stamp()).incremented())
.min(Height::from(self.loadedaddressindex_to_loadedaddressdata.stamp()).incremented())
.min(Height::from(self.emptyaddressindex_to_emptyaddressdata.stamp()).incremented())
.min(Height::from(self.height_to_unspendable_supply.len()))
.min(Height::from(self.height_to_opreturn_supply.len()))
.cmp(&chain_state_starting_height)
@@ -745,7 +695,7 @@ impl Vecs {
.try_for_each(|(_, v)| v.state.reset_price_to_amount())?;
};
let last_height = Height::from(u64::from(indexer.vecs.height_to_blockhash.stamp()));
let last_height = Height::from(indexer.vecs.height_to_blockhash.stamp());
if starting_height <= last_height {
let inputindex_to_outputindex_reader = inputindex_to_outputindex.create_reader();
@@ -836,7 +786,7 @@ impl Vecs {
(height.unwrap_to_usize()..height_to_date_fixed.len())
.map(Height::from)
.try_for_each(|_height| -> color_eyre::Result<()> {
.try_for_each(|_height| -> Result<()> {
height = _height;
info!("Processing chain at {height}...");
@@ -903,7 +853,7 @@ impl Vecs {
.tick_tock_next_block(&chain_state, timestamp);
});
let (transacted, addresstype_to_typedindex_to_received_data, receiving_addresstype_to_typeindex_to_addressdatawithsource) = (first_outputindex..first_outputindex + *output_count)
let (transacted, addresstype_to_typedindex_to_received_data, receiving_addresstype_to_typeindex_to_addressdatawithsource) = (first_outputindex..first_outputindex + usize::from(output_count))
.into_par_iter()
.map(OutputIndex::from)
.map(|outputindex| {
@@ -987,7 +937,7 @@ impl Vecs {
);
// Skip coinbase
let (height_to_sent, addresstype_to_typedindex_to_sent_data, sending_addresstype_to_typeindex_to_addressdatawithsource) = (first_inputindex + 1..first_inputindex + *input_count)
let (height_to_sent, addresstype_to_typedindex_to_sent_data, sending_addresstype_to_typeindex_to_addressdatawithsource) = (first_inputindex + 1..first_inputindex + usize::from(input_count))
.into_par_iter()
.map(InputIndex::from)
.map(|inputindex| {
@@ -1287,7 +1237,8 @@ impl Vecs {
.map(|(_, v)| v)
.collect::<Vec<_>>(),
exit,
)
)?;
Ok(())
},
)?;
@@ -1306,14 +1257,15 @@ impl Vecs {
.map(|(_, v)| v)
.collect::<Vec<_>>(),
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_unspendable_supply.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(&self.height_to_unspendable_supply),
@@ -1321,7 +1273,7 @@ impl Vecs {
self.indexes_to_opreturn_supply.compute_rest(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
Some(&self.height_to_opreturn_supply),
@@ -1342,15 +1294,10 @@ impl Vecs {
)?;
self.utxo_cohorts
.compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)?;
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)?;
self.address_cohorts.compute_rest_part1(
indexer,
indexes,
fetched,
starting_indexes,
exit,
)?;
self.address_cohorts
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)?;
info!("Computing rest part 2...");
@@ -1384,7 +1331,7 @@ impl Vecs {
self.utxo_cohorts.compute_rest_part2(
indexer,
indexes,
fetched,
price,
starting_indexes,
market,
height_to_supply,
@@ -1397,7 +1344,7 @@ impl Vecs {
self.address_cohorts.compute_rest_part2(
indexer,
indexes,
fetched,
price,
starting_indexes,
market,
height_to_supply,
@@ -1407,6 +1354,8 @@ impl Vecs {
exit,
)?;
self.file.flush()?;
self.file.punch_holes()?;
Ok(())
}
@@ -1423,16 +1372,16 @@ impl Vecs {
>,
addresstypeindex_to_anyaddressindex_reader_opt: &ByAddressType<Option<Reader>>,
anyaddressindex_to_anyaddressdata_reader_opt: &ByAnyAddress<Option<Reader>>,
p2pk33addressindex_to_anyaddressindex: &StampedVec<P2PK33AddressIndex, AnyAddressIndex>,
p2pk65addressindex_to_anyaddressindex: &StampedVec<P2PK65AddressIndex, AnyAddressIndex>,
p2pkhaddressindex_to_anyaddressindex: &StampedVec<P2PKHAddressIndex, AnyAddressIndex>,
p2shaddressindex_to_anyaddressindex: &StampedVec<P2SHAddressIndex, AnyAddressIndex>,
p2traddressindex_to_anyaddressindex: &StampedVec<P2TRAddressIndex, AnyAddressIndex>,
p2wpkhaddressindex_to_anyaddressindex: &StampedVec<P2WPKHAddressIndex, AnyAddressIndex>,
p2wshaddressindex_to_anyaddressindex: &StampedVec<P2WSHAddressIndex, AnyAddressIndex>,
p2aaddressindex_to_anyaddressindex: &StampedVec<P2AAddressIndex, AnyAddressIndex>,
loadedaddressindex_to_loadedaddressdata: &StampedVec<LoadedAddressIndex, LoadedAddressData>,
emptyaddressindex_to_emptyaddressdata: &StampedVec<EmptyAddressIndex, EmptyAddressData>,
p2pk33addressindex_to_anyaddressindex: &RawVec<P2PK33AddressIndex, AnyAddressIndex>,
p2pk65addressindex_to_anyaddressindex: &RawVec<P2PK65AddressIndex, AnyAddressIndex>,
p2pkhaddressindex_to_anyaddressindex: &RawVec<P2PKHAddressIndex, AnyAddressIndex>,
p2shaddressindex_to_anyaddressindex: &RawVec<P2SHAddressIndex, AnyAddressIndex>,
p2traddressindex_to_anyaddressindex: &RawVec<P2TRAddressIndex, AnyAddressIndex>,
p2wpkhaddressindex_to_anyaddressindex: &RawVec<P2WPKHAddressIndex, AnyAddressIndex>,
p2wshaddressindex_to_anyaddressindex: &RawVec<P2WSHAddressIndex, AnyAddressIndex>,
p2aaddressindex_to_anyaddressindex: &RawVec<P2AAddressIndex, AnyAddressIndex>,
loadedaddressindex_to_loadedaddressdata: &RawVec<LoadedAddressIndex, LoadedAddressData>,
emptyaddressindex_to_emptyaddressdata: &RawVec<EmptyAddressIndex, EmptyAddressData>,
) -> Option<WithAddressDataSource<LoadedAddressData>> {
if *first_addressindexes.get(address_type).unwrap() <= typeindex {
return Some(WithAddressDataSource::New(LoadedAddressData::default()));
@@ -1643,7 +1592,8 @@ impl Vecs {
emptyaddressdata,
)) => self
.emptyaddressindex_to_emptyaddressdata
.update(emptyaddressindex, emptyaddressdata),
.update(emptyaddressindex, emptyaddressdata)
.map_err(|e| e.into()),
WithAddressDataSource::FromLoadedAddressDataVec((
loadedaddressindex,
emptyaddressdata,
@@ -1695,7 +1645,8 @@ impl Vecs {
loadedaddressdata,
)) => self
.loadedaddressindex_to_loadedaddressdata
.update(loadedaddressindex, loadedaddressdata),
.update(loadedaddressindex, loadedaddressdata)
.map_err(|e| e.into()),
WithAddressDataSource::FromEmptyAddressDataVec((
emptyaddressindex,
loadedaddressdata,
@@ -1753,30 +1704,31 @@ impl Vecs {
.p2aaddressindex_to_anyaddressindex
.update_or_push(typeindex.into(), anyaddressindex),
_ => unreachable!(),
}
}?;
Ok(())
})
})?;
self.p2pk33addressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.p2pk65addressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.p2pkhaddressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.p2shaddressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.p2traddressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.p2wpkhaddressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.p2wshaddressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.p2aaddressindex_to_anyaddressindex
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.loadedaddressindex_to_loadedaddressdata
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.emptyaddressindex_to_emptyaddressdata
.flush(Stamp::from(u64::from(height)))?;
.stamped_flush(Stamp::from(height))?;
self.chain_state.truncate_if_needed(Height::ZERO)?;
chain_state.iter().for_each(|block_state| {
@@ -1838,8 +1790,8 @@ impl AddressTypeToVec<(TypeIndex, Sats)> {
WithAddressDataSource<EmptyAddressData>,
>,
price: Option<Dollars>,
addresstype_to_address_count: &mut ByAddressType<usize>,
addresstype_to_empty_address_count: &mut ByAddressType<usize>,
addresstype_to_address_count: &mut ByAddressType<u64>,
addresstype_to_empty_address_count: &mut ByAddressType<u64>,
stored_or_new_addresstype_to_typeindex_to_addressdatawithsource: &mut AddressTypeToTypeIndexTree<
WithAddressDataSource<LoadedAddressData>,
>,
@@ -1928,9 +1880,9 @@ impl HeightToAddressTypeToVec<(TypeIndex, Sats)> {
WithAddressDataSource<EmptyAddressData>,
>,
price: Option<Dollars>,
addresstype_to_address_count: &mut ByAddressType<usize>,
addresstype_to_empty_address_count: &mut ByAddressType<usize>,
height_to_close_vec: Option<&Vec<brk_core::Close<Dollars>>>,
addresstype_to_address_count: &mut ByAddressType<u64>,
addresstype_to_empty_address_count: &mut ByAddressType<u64>,
height_to_close_vec: Option<&Vec<brk_structs::Close<Dollars>>>,
height_to_timestamp_fixed_vec: &[Timestamp],
height: Height,
timestamp: Timestamp,

22
crates/brk_computer/src/stateful/range_map.rs
View File

@@ -1,6 +1,6 @@
use std::collections::BTreeMap;
use brk_vecs::{StampedVec, StoredIndex, StoredType};
use brk_vecs::{CompressedVec, RawVec, StoredCompressed, StoredIndex, StoredRaw};
#[derive(Debug)]
pub struct RangeMap<I, T>(BTreeMap<I, T>);
@@ -20,12 +20,26 @@ where
}
}
impl<I, T> From<&StampedVec<I, T>> for RangeMap<T, I>
impl<I, T> From<&RawVec<I, T>> for RangeMap<T, I>
where
I: StoredIndex,
T: StoredIndex + StoredType,
T: StoredIndex + StoredRaw,
{
fn from(vec: &StampedVec<I, T>) -> Self {
fn from(vec: &RawVec<I, T>) -> Self {
Self(
vec.into_iter()
.map(|(i, v)| (v.into_owned(), i))
.collect::<BTreeMap<_, _>>(),
)
}
}
impl<I, T> From<&CompressedVec<I, T>> for RangeMap<T, I>
where
I: StoredIndex,
T: StoredIndex + StoredCompressed,
{
fn from(vec: &CompressedVec<I, T>) -> Self {
Self(
vec.into_iter()
.map(|(i, v)| (v.into_owned(), i))

16
crates/brk_computer/src/stateful/trait.rs
View File

@@ -1,9 +1,9 @@
use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, AnyIterableVec};
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use brk_vecs::{AnyCollectableVec, AnyIterableVec, Exit};
use crate::{Indexes, fetched, indexes, market};
use crate::{Indexes, indexes, market, price};
pub trait DynCohortVecs: Send + Sync {
fn starting_height(&self) -> Height;
@@ -30,10 +30,10 @@ pub trait DynCohortVecs: Send + Sync {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()>;
) -> Result<()>;
fn vecs(&self) -> Vec<&dyn AnyCollectableVec>;
}
@@ -51,7 +51,7 @@ pub trait CohortVecs: DynCohortVecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
@@ -59,5 +59,5 @@ pub trait CohortVecs: DynCohortVecs {
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()>;
) -> Result<()>;
}

28
crates/brk_computer/src/stateful/utxo_cohort.rs
View File

@@ -1,12 +1,12 @@
use std::{ops::Deref, path::Path, sync::Arc};
use brk_core::{Bitcoin, DateIndex, Dollars, Height, Result, Version};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_vecs::{AnyCollectableVec, AnyIterableVec, Computation, File, Format};
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use brk_vecs::{AnyCollectableVec, AnyIterableVec, Computation, Exit, File, Format};
use crate::{
Indexes, UTXOCohortState, fetched, indexes, market,
Indexes, UTXOCohortState, indexes, market, price,
stateful::{
common,
r#trait::{CohortVecs, DynCohortVecs},
@@ -31,12 +31,12 @@ impl Vecs {
format: Format,
version: Version,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
states_path: &Path,
compute_relative_to_all: bool,
ratio_extended: bool,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
) -> Result<Self> {
let compute_dollars = price.is_some();
Ok(Self {
starting_height: Height::ZERO,
@@ -54,7 +54,7 @@ impl Vecs {
format,
version,
indexes,
fetched,
price,
compute_relative_to_all,
ratio_extended,
)?,
@@ -123,12 +123,12 @@ impl DynCohortVecs for Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.inner
.compute_rest_part1(indexer, indexes, fetched, starting_indexes, exit)
.compute_rest_part1(indexer, indexes, price, starting_indexes, exit)
}
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
@@ -155,7 +155,7 @@ impl CohortVecs for Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
starting_indexes: &Indexes,
market: &market::Vecs,
height_to_supply: &impl AnyIterableVec<Height, Bitcoin>,
@@ -163,11 +163,11 @@ impl CohortVecs for Vecs {
height_to_realized_cap: Option<&impl AnyIterableVec<Height, Dollars>>,
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.inner.compute_rest_part2(
indexer,
indexes,
fetched,
price,
starting_indexes,
market,
height_to_supply,

260
crates/brk_computer/src/stateful/utxo_cohorts.rs
View File

File diff suppressed because it is too large Load Diff

2
crates/brk_computer/src/stateful/withaddressdatasource.rs
View File

@@ -1,4 +1,4 @@
use brk_core::{EmptyAddressData, EmptyAddressIndex, LoadedAddressData, LoadedAddressIndex};
use brk_structs::{EmptyAddressData, EmptyAddressIndex, LoadedAddressData, LoadedAddressIndex};
#[derive(Debug)]
pub enum WithAddressDataSource<T> {

2
crates/brk_computer/src/states/block.rs
View File

@@ -1,6 +1,6 @@
use std::ops::{Add, AddAssign, SubAssign};
use brk_core::{Dollars, Timestamp};
use brk_structs::{Dollars, Timestamp};
use super::SupplyState;

13
crates/brk_computer/src/states/cohorts/address.rs
View File

@@ -1,6 +1,7 @@
use std::path::Path;
use brk_core::{Dollars, Height, LoadedAddressData, Result, Sats};
use brk_error::Result;
use brk_structs::{Dollars, Height, LoadedAddressData, Sats};
use crate::SupplyState;
@@ -8,7 +9,7 @@ use super::CohortState;
#[derive(Clone)]
pub struct AddressCohortState {
pub address_count: usize,
pub address_count: u64,
pub inner: CohortState,
}
@@ -47,14 +48,14 @@ impl AddressCohortState {
let prev_realized_price = compute_price.then(|| addressdata.realized_price());
let prev_supply_state = SupplyState {
utxos: addressdata.outputs_len as usize,
utxos: addressdata.outputs_len as u64,
value: addressdata.amount(),
};
addressdata.send(value, prev_price)?;
let supply_state = SupplyState {
utxos: addressdata.outputs_len as usize,
utxos: addressdata.outputs_len as u64,
value: addressdata.amount(),
};
@@ -82,14 +83,14 @@ impl AddressCohortState {
let prev_realized_price = compute_price.then(|| address_data.realized_price());
let prev_supply_state = SupplyState {
utxos: address_data.outputs_len as usize,
utxos: address_data.outputs_len as u64,
value: address_data.amount(),
};
address_data.receive(value, price);
let supply_state = SupplyState {
utxos: address_data.outputs_len as usize,
utxos: address_data.outputs_len as u64,
value: address_data.amount(),
};

3
crates/brk_computer/src/states/cohorts/common.rs
View File

@@ -1,6 +1,7 @@
use std::{cmp::Ordering, path::Path};
use brk_core::{CheckedSub, Dollars, Height, Result, Sats};
use brk_error::Result;
use brk_structs::{CheckedSub, Dollars, Height, Sats};
use crate::{PriceToAmount, RealizedState, SupplyState, UnrealizedState};

3
crates/brk_computer/src/states/cohorts/utxo.rs
View File

@@ -1,6 +1,7 @@
use std::path::Path;
use brk_core::{Height, Result};
use brk_error::Result;
use brk_structs::Height;
use derive_deref::{Deref, DerefMut};
use super::CohortState;

3
crates/brk_computer/src/states/price_to_amount.rs
View File

@@ -5,7 +5,8 @@ use std::{
path::{Path, PathBuf},
};
use brk_core::{Dollars, Error, Height, Result, Sats};
use brk_error::{Error, Result};
use brk_structs::{Dollars, Height, Sats};
use derive_deref::{Deref, DerefMut};
use serde::{Deserialize, Serialize};
use zerocopy::{FromBytes, IntoBytes};

2
crates/brk_computer/src/states/realized.rs
View File

@@ -1,6 +1,6 @@
use std::cmp::Ordering;
use brk_core::{CheckedSub, Dollars};
use brk_structs::{CheckedSub, Dollars};
use super::SupplyState;

6
crates/brk_computer/src/states/supply.rs
View File

@@ -1,12 +1,12 @@
use std::ops::{Add, AddAssign, SubAssign};
use brk_core::{CheckedSub, LoadedAddressData, Sats};
use brk_structs::{CheckedSub, LoadedAddressData, 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 utxos: u64,
pub value: Sats,
}
@@ -43,7 +43,7 @@ impl SubAssign<&SupplyState> for SupplyState {
impl From<&LoadedAddressData> for SupplyState {
fn from(value: &LoadedAddressData) -> Self {
Self {
utxos: value.outputs_len as usize,
utxos: value.outputs_len as u64,
value: value.amount(),
}
}

2
crates/brk_computer/src/states/transacted.rs
View File

@@ -1,6 +1,6 @@
use std::ops::{Add, AddAssign};
use brk_core::{ByAmountRange, GroupedByType, OutputType, Sats};
use brk_structs::{ByAmountRange, GroupedByType, OutputType, Sats};
use super::SupplyState;

2
crates/brk_computer/src/states/unrealized.rs
View File

@@ -1,4 +1,4 @@
use brk_core::{Dollars, Sats};
use brk_structs::{Dollars, Sats};
#[derive(Debug, Default, Clone)]
pub struct UnrealizedState {

316
crates/brk_computer/src/traits.rs Normal file
View File

@@ -0,0 +1,316 @@
use brk_error::Result;
use brk_structs::{Bitcoin, CheckedSub, Close, Date, DateIndex, Dollars, Sats, StoredF32};
use brk_vecs::{
AnyIterableVec, AnyStoredVec, AnyVec, EagerVec, Exit, GenericStoredVec, StoredIndex,
VecIterator, Version,
};
const DCA_AMOUNT: Dollars = Dollars::mint(100.0);
pub trait ComputeDCAStackViaLen {
fn compute_dca_stack_via_len(
&mut self,
max_from: DateIndex,
closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>,
len: usize,
exit: &Exit,
) -> Result<()>;
fn compute_dca_stack_via_from(
&mut self,
max_from: DateIndex,
closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>,
from: DateIndex,
exit: &Exit,
) -> Result<()>;
}
impl ComputeDCAStackViaLen for EagerVec<DateIndex, Sats> {
fn compute_dca_stack_via_len(
&mut self,
max_from: DateIndex,
closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>,
len: usize,
exit: &Exit,
) -> Result<()> {
self.validate_computed_version_or_reset_file(
Version::ZERO + self.inner_version() + closes.version(),
)?;
let mut other_iter = closes.iter();
let mut prev = None;
let index = max_from.min(DateIndex::from(self.len()));
closes.iter_at(index).try_for_each(|(i, closes)| {
let price = *closes.into_owned();
let i_usize = i.unwrap_to_usize();
if prev.is_none() {
if i_usize == 0 {
prev.replace(Sats::ZERO);
} else {
prev.replace(self.into_iter().unwrap_get_inner_(i_usize - 1));
}
}
let mut stack = Sats::ZERO;
if price != Dollars::ZERO {
stack = prev.unwrap() + Sats::from(Bitcoin::from(DCA_AMOUNT / price));
if i_usize >= len {
let prev_price = *other_iter.unwrap_get_inner_(i_usize - len);
if prev_price != Dollars::ZERO {
stack = stack
.checked_sub(Sats::from(Bitcoin::from(DCA_AMOUNT / prev_price)))
.unwrap();
}
}
}
prev.replace(stack);
self.forced_push_at(i, stack, exit)
})?;
self.safe_flush(exit)?;
Ok(())
}
fn compute_dca_stack_via_from(
&mut self,
max_from: DateIndex,
closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>,
from: DateIndex,
exit: &Exit,
) -> Result<()> {
self.validate_computed_version_or_reset_file(
Version::ZERO + self.inner_version() + closes.version(),
)?;
let mut prev = None;
let index = max_from.min(DateIndex::from(self.len()));
closes.iter_at(index).try_for_each(|(i, closes)| {
let price = *closes.into_owned();
let i_usize = i.unwrap_to_usize();
if prev.is_none() {
if i_usize == 0 {
prev.replace(Sats::ZERO);
} else {
prev.replace(self.into_iter().unwrap_get_inner_(i_usize - 1));
}
}
let mut stack = Sats::ZERO;
if price != Dollars::ZERO && i >= from {
stack = prev.unwrap() + Sats::from(Bitcoin::from(DCA_AMOUNT / price));
}
prev.replace(stack);
self.forced_push_at(i, stack, exit)
})?;
self.safe_flush(exit)?;
Ok(())
}
}
pub trait ComputeDCAAveragePriceViaLen {
fn compute_dca_avg_price_via_len(
&mut self,
max_from: DateIndex,
stacks: &impl AnyIterableVec<DateIndex, Sats>,
len: usize,
exit: &Exit,
) -> Result<()>;
fn compute_dca_avg_price_via_from(
&mut self,
max_from: DateIndex,
stacks: &impl AnyIterableVec<DateIndex, Sats>,
from: DateIndex,
exit: &Exit,
) -> Result<()>;
}
impl ComputeDCAAveragePriceViaLen for EagerVec<DateIndex, Dollars> {
fn compute_dca_avg_price_via_len(
&mut self,
max_from: DateIndex,
stacks: &impl AnyIterableVec<DateIndex, Sats>,
len: usize,
exit: &Exit,
) -> Result<()> {
self.validate_computed_version_or_reset_file(
Version::ONE + self.inner_version() + stacks.version(),
)?;
let index = max_from.min(DateIndex::from(self.len()));
let first_price_date = DateIndex::try_from(Date::new(2010, 7, 12)).unwrap();
stacks.iter_at(index).try_for_each(|(i, stack)| {
let stack = stack.into_owned();
let mut avg_price = Dollars::from(f64::NAN);
if i > first_price_date {
avg_price = DCA_AMOUNT
* len
.min(i.unwrap_to_usize() + 1)
.min(i.checked_sub(first_price_date).unwrap().unwrap_to_usize() + 1)
/ Bitcoin::from(stack);
}
self.forced_push_at(i, avg_price, exit)
})?;
self.safe_flush(exit)?;
Ok(())
}
fn compute_dca_avg_price_via_from(
&mut self,
max_from: DateIndex,
stacks: &impl AnyIterableVec<DateIndex, Sats>,
from: DateIndex,
exit: &Exit,
) -> Result<()> {
self.validate_computed_version_or_reset_file(
Version::ZERO + self.inner_version() + stacks.version(),
)?;
let index = max_from.min(DateIndex::from(self.len()));
let from_usize = from.unwrap_to_usize();
stacks.iter_at(index).try_for_each(|(i, stack)| {
let stack = stack.into_owned();
let mut avg_price = Dollars::from(f64::NAN);
if i >= from {
avg_price =
DCA_AMOUNT * (i.unwrap_to_usize() + 1 - from_usize) / Bitcoin::from(stack);
}
self.forced_push_at(i, avg_price, exit)
})?;
self.safe_flush(exit)?;
Ok(())
}
}
pub trait ComputeFromSats<I> {
fn compute_from_sats(
&mut self,
max_from: I,
sats: &impl AnyIterableVec<I, Sats>,
exit: &Exit,
) -> Result<()>;
}
impl<I> ComputeFromSats<I> for EagerVec<I, Bitcoin>
where
I: StoredIndex,
{
fn compute_from_sats(
&mut self,
max_from: I,
sats: &impl AnyIterableVec<I, Sats>,
exit: &Exit,
) -> Result<()> {
self.validate_computed_version_or_reset_file(
Version::ZERO + self.inner_version() + sats.version(),
)?;
let index = max_from.min(I::from(self.len()));
sats.iter_at(index).try_for_each(|(i, sats)| {
let (i, v) = (i, Bitcoin::from(sats.into_owned()));
self.forced_push_at(i, v, exit)
})?;
self.safe_flush(exit)?;
Ok(())
}
}
pub trait ComputeFromBitcoin<I> {
fn compute_from_bitcoin(
&mut self,
max_from: I,
bitcoin: &impl AnyIterableVec<I, Bitcoin>,
price: &impl AnyIterableVec<I, Close<Dollars>>,
exit: &Exit,
) -> Result<()>;
}
impl<I> ComputeFromBitcoin<I> for EagerVec<I, Dollars>
where
I: StoredIndex,
{
fn compute_from_bitcoin(
&mut self,
max_from: I,
bitcoin: &impl AnyIterableVec<I, Bitcoin>,
price: &impl AnyIterableVec<I, Close<Dollars>>,
exit: &Exit,
) -> Result<()> {
self.validate_computed_version_or_reset_file(
Version::ZERO + self.inner_version() + bitcoin.version(),
)?;
let mut price_iter = price.iter();
let index = max_from.min(I::from(self.len()));
bitcoin.iter_at(index).try_for_each(|(i, bitcoin)| {
let dollars = price_iter.unwrap_get_inner(i);
let (i, v) = (i, *dollars * bitcoin.into_owned());
self.forced_push_at(i, v, exit)
})?;
self.safe_flush(exit)?;
Ok(())
}
}
pub trait ComputeDrawdown<I> {
fn compute_drawdown(
&mut self,
max_from: I,
close: &impl AnyIterableVec<I, Close<Dollars>>,
ath: &impl AnyIterableVec<I, Dollars>,
exit: &Exit,
) -> Result<()>;
}
impl<I> ComputeDrawdown<I> for EagerVec<I, StoredF32>
where
I: StoredIndex,
{
fn compute_drawdown(
&mut self,
max_from: I,
close: &impl AnyIterableVec<I, Close<Dollars>>,
ath: &impl AnyIterableVec<I, Dollars>,
exit: &Exit,
) -> Result<()> {
self.validate_computed_version_or_reset_file(
Version::ZERO + self.inner_version() + ath.version() + close.version(),
)?;
let index = max_from.min(I::from(self.len()));
let mut close_iter = close.iter();
ath.iter_at(index).try_for_each(|(i, ath)| {
let ath = ath.into_owned();
if ath == Dollars::ZERO {
self.forced_push_at(i, StoredF32::default(), exit)
} else {
let close = *close_iter.unwrap_get_inner(i);
let drawdown = StoredF32::from((*ath - *close) / *ath * -100.0);
self.forced_push_at(i, drawdown, exit)
}
})?;
self.safe_flush(exit)?;
Ok(())
}
}

254
crates/brk_computer/src/transactions.rs
View File

@@ -1,14 +1,15 @@
use std::sync::Arc;
use std::{path::Path, sync::Arc};
use brk_core::{
CheckedSub, Feerate, HalvingEpoch, Height, InputIndex, OutputIndex, Sats, StoredU32,
StoredUsize, TxIndex, TxVersion, Version, Weight,
};
use brk_exit::Exit;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{
CheckedSub, Feerate, HalvingEpoch, Height, InputIndex, OutputIndex, Sats, StoredBool,
StoredU32, StoredU64, TxIndex, TxVersion, Version, Weight,
};
use brk_vecs::{
AnyCollectableVec, AnyIterableVec, CloneableAnyIterableVec, Computation, ComputedVec,
ComputedVecFrom1, ComputedVecFrom2, ComputedVecFrom3, File, Format, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Computation, ComputedVec,
ComputedVecFrom1, ComputedVecFrom2, ComputedVecFrom3, Exit, File, Format, StoredIndex,
VecIterator,
};
use crate::grouped::{
@@ -16,89 +17,86 @@ use crate::grouped::{
ComputedVecsFromTxindex, Source, VecBuilderOptions,
};
use super::{Indexes, fetched, indexes};
use super::{Indexes, indexes, price};
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
pub struct Vecs {
file: Arc<File>,
// pub txindex_to_is_v1: LazyVec<Txindex, bool>,
// pub txindex_to_is_v2: LazyVec<Txindex, bool>,
// pub txindex_to_is_v3: LazyVec<Txindex, bool>,
pub indexes_to_coinbase: ComputedValueVecsFromHeight,
pub indexes_to_emptyoutput_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_emptyoutput_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_fee: ComputedValueVecsFromTxindex,
pub indexes_to_feerate: ComputedVecsFromTxindex<Feerate>,
/// Value == 0 when Coinbase
pub txindex_to_input_value: ComputedVecFrom3<
TxIndex,
Sats,
TxIndex,
InputIndex,
TxIndex,
StoredUsize,
InputIndex,
Sats,
>,
pub txindex_to_input_value:
ComputedVecFrom3<TxIndex, Sats, TxIndex, InputIndex, TxIndex, StoredU64, InputIndex, Sats>,
// pub indexes_to_input_value: ComputedVecsFromTxindex<Sats>,
pub indexes_to_opreturn_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_opreturn_count: ComputedVecsFromHeight<StoredU64>,
pub txindex_to_output_value: ComputedVecFrom3<
TxIndex,
Sats,
TxIndex,
OutputIndex,
TxIndex,
StoredUsize,
StoredU64,
OutputIndex,
Sats,
>,
// pub indexes_to_output_value: ComputedVecsFromTxindex<Sats>,
pub indexes_to_p2a_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2ms_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2pk33_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2pk65_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2pkh_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2sh_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2tr_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2wpkh_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2wsh_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_p2a_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2ms_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2pk33_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2pk65_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2pkh_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2sh_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2tr_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2wpkh_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_p2wsh_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_subsidy: ComputedValueVecsFromHeight,
pub indexes_to_unclaimed_rewards: ComputedValueVecsFromHeight,
pub indexes_to_tx_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_tx_v1: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_tx_v2: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_tx_v3: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_tx_vsize: ComputedVecsFromTxindex<StoredUsize>,
pub indexes_to_tx_count: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_tx_v1: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_tx_v2: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_tx_v3: ComputedVecsFromHeight<StoredU64>,
pub indexes_to_tx_vsize: ComputedVecsFromTxindex<StoredU64>,
pub indexes_to_tx_weight: ComputedVecsFromTxindex<Weight>,
pub indexes_to_unknownoutput_count: ComputedVecsFromHeight<StoredUsize>,
pub indexes_to_unknownoutput_count: ComputedVecsFromHeight<StoredU64>,
pub inputindex_to_value:
ComputedVecFrom2<InputIndex, Sats, InputIndex, OutputIndex, OutputIndex, Sats>,
pub indexes_to_input_count: ComputedVecsFromTxindex<StoredUsize>,
pub txindex_to_is_coinbase: ComputedVecFrom2<TxIndex, bool, TxIndex, Height, Height, TxIndex>,
pub indexes_to_output_count: ComputedVecsFromTxindex<StoredUsize>,
pub txindex_to_vsize: ComputedVecFrom1<TxIndex, StoredUsize, TxIndex, Weight>,
pub indexes_to_input_count: ComputedVecsFromTxindex<StoredU64>,
pub txindex_to_is_coinbase:
ComputedVecFrom2<TxIndex, StoredBool, TxIndex, Height, Height, TxIndex>,
pub indexes_to_output_count: ComputedVecsFromTxindex<StoredU64>,
pub txindex_to_vsize: ComputedVecFrom1<TxIndex, StoredU64, TxIndex, Weight>,
pub txindex_to_weight:
ComputedVecFrom2<TxIndex, Weight, TxIndex, StoredU32, TxIndex, StoredU32>,
pub txindex_to_fee: ComputedVecFrom2<TxIndex, Sats, TxIndex, Sats, TxIndex, Sats>,
pub txindex_to_feerate: ComputedVecFrom2<TxIndex, Feerate, TxIndex, Sats, TxIndex, StoredUsize>,
pub indexes_to_exact_utxo_count: ComputedVecsFromHeight<StoredUsize>,
pub txindex_to_feerate: ComputedVecFrom2<TxIndex, Feerate, TxIndex, Sats, TxIndex, StoredU64>,
pub indexes_to_exact_utxo_count: ComputedVecsFromHeight<StoredU64>,
}
impl Vecs {
pub fn forced_import(
file: &Arc<File>,
parent: &Path,
version: Version,
indexer: &Indexer,
indexes: &indexes::Vecs,
computation: Computation,
format: Format,
fetched: Option<&fetched::Vecs>,
) -> color_eyre::Result<Self> {
let compute_dollars = fetched.is_some();
price: Option<&price::Vecs>,
) -> Result<Self> {
let file = Arc::new(File::open(&parent.join("transactions"))?);
let compute_dollars = price.is_some();
let inputindex_to_value = ComputedVec::forced_import_or_init_from_2(
computation,
file,
&file,
"value",
version + VERSION + Version::ZERO,
format,
@@ -125,7 +123,7 @@ impl Vecs {
let txindex_to_weight = ComputedVec::forced_import_or_init_from_2(
computation,
file,
&file,
"weight",
version + VERSION + Version::ZERO,
format,
@@ -153,7 +151,7 @@ impl Vecs {
let txindex_to_vsize = ComputedVec::forced_import_or_init_from_1(
computation,
file,
&file,
"vsize",
version + VERSION + Version::ZERO,
format,
@@ -161,7 +159,7 @@ impl Vecs {
|index: TxIndex, iter| {
let index = index.unwrap_to_usize();
iter.next_at(index).map(|(_, weight)| {
StoredUsize::from(
StoredU64::from(
bitcoin::Weight::from(weight.into_owned()).to_vbytes_ceil() as usize
)
})
@@ -170,7 +168,7 @@ impl Vecs {
let txindex_to_is_coinbase = ComputedVec::forced_import_or_init_from_2(
computation,
file,
&file,
"is_coinbase",
version + VERSION + Version::ZERO,
format,
@@ -186,15 +184,14 @@ impl Vecs {
.unwrap()
.1
.into_owned();
index == txindex
StoredBool::from(index == txindex)
})
},
)?;
let txindex_to_input_value = ComputedVec::forced_import_or_init_from_3(
computation,
file,
&file,
"input_value",
version + VERSION + Version::ZERO,
format,
@@ -215,7 +212,7 @@ impl Vecs {
.unwrap()
.1
.into_owned();
let range = first_index..first_index + count;
let range = first_index..first_index + count as usize;
range.into_iter().fold(Sats::ZERO, |total, inputindex| {
total
+ inputindex_to_value_iter
@@ -244,7 +241,7 @@ impl Vecs {
let txindex_to_output_value = ComputedVec::forced_import_or_init_from_3(
computation,
file,
&file,
"output_value",
version + VERSION + Version::ZERO,
format,
@@ -265,7 +262,7 @@ impl Vecs {
.unwrap()
.1
.into_owned();
let range = first_index..first_index + count;
let range = first_index..first_index + count as usize;
range.into_iter().fold(Sats::ZERO, |total, outputindex| {
total
+ outputindex_to_value_iter
@@ -294,7 +291,7 @@ impl Vecs {
let txindex_to_fee = ComputedVecFrom2::forced_import_or_init_from_2(
computation,
file,
&file,
"fee",
version + VERSION + Version::ZERO,
format,
@@ -317,7 +314,7 @@ impl Vecs {
let txindex_to_feerate = ComputedVecFrom2::forced_import_or_init_from_2(
computation,
file,
&file,
"feerate",
version + VERSION + Version::ZERO,
format,
@@ -337,7 +334,7 @@ impl Vecs {
Ok(Self {
indexes_to_tx_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"tx_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -352,7 +349,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_input_count: ComputedVecsFromTxindex::forced_import(
file,
&file,
"input_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -367,7 +364,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_output_count: ComputedVecsFromTxindex::forced_import(
file,
&file,
"output_count",
Source::None,
version + VERSION + Version::ZERO,
@@ -382,7 +379,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_tx_v1: ComputedVecsFromHeight::forced_import(
file,
&file,
"tx_v1",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -392,7 +389,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_tx_v2: ComputedVecsFromHeight::forced_import(
file,
&file,
"tx_v2",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -402,7 +399,7 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_tx_v3: ComputedVecsFromHeight::forced_import(
file,
&file,
"tx_v3",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -412,14 +409,14 @@ impl Vecs {
VecBuilderOptions::default().add_sum().add_cumulative(),
)?,
indexes_to_fee: ComputedValueVecsFromTxindex::forced_import(
file,
&file,
"fee",
indexes,
Source::Vec(txindex_to_fee.boxed_clone()),
version + VERSION + Version::ZERO,
computation,
format,
fetched,
price,
VecBuilderOptions::default()
.add_sum()
.add_cumulative()
@@ -428,7 +425,7 @@ impl Vecs {
.add_average(),
)?,
indexes_to_feerate: ComputedVecsFromTxindex::forced_import(
file,
&file,
"feerate",
Source::None,
version + VERSION + Version::ZERO,
@@ -441,7 +438,7 @@ impl Vecs {
.add_average(),
)?,
indexes_to_tx_vsize: ComputedVecsFromTxindex::forced_import(
file,
&file,
"tx_vsize",
Source::None,
version + VERSION + Version::ZERO,
@@ -454,7 +451,7 @@ impl Vecs {
.add_average(),
)?,
indexes_to_tx_weight: ComputedVecsFromTxindex::forced_import(
file,
&file,
"tx_weight",
Source::None,
version + VERSION + Version::ZERO,
@@ -467,7 +464,7 @@ impl Vecs {
.add_average(),
)?,
indexes_to_subsidy: ComputedValueVecsFromHeight::forced_import(
file,
&file,
"subsidy",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -483,7 +480,7 @@ impl Vecs {
indexes,
)?,
indexes_to_coinbase: ComputedValueVecsFromHeight::forced_import(
file,
&file,
"coinbase",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -499,7 +496,7 @@ impl Vecs {
indexes,
)?,
indexes_to_unclaimed_rewards: ComputedValueVecsFromHeight::forced_import(
file,
&file,
"unclaimed_rewards",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -510,7 +507,7 @@ impl Vecs {
indexes,
)?,
indexes_to_p2a_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2a_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -525,7 +522,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2ms_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2ms_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -540,7 +537,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2pk33_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pk33_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -555,7 +552,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2pk65_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pk65_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -570,7 +567,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2pkh_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2pkh_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -585,7 +582,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2sh_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2sh_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -600,7 +597,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2tr_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2tr_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -615,7 +612,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2wpkh_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2wpkh_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -630,7 +627,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_p2wsh_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"p2wsh_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -645,7 +642,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_opreturn_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"opreturn_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -660,7 +657,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_unknownoutput_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"unknownoutput_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -675,7 +672,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_emptyoutput_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"emptyoutput_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -690,7 +687,7 @@ impl Vecs {
.add_cumulative(),
)?,
indexes_to_exact_utxo_count: ComputedVecsFromHeight::forced_import(
file,
&file,
"exact_utxo_count",
Source::Compute,
version + VERSION + Version::ZERO,
@@ -709,6 +706,8 @@ impl Vecs {
txindex_to_feerate,
txindex_to_vsize,
txindex_to_weight,
file,
})
}
@@ -717,9 +716,9 @@ impl Vecs {
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
fetched: Option<&fetched::Vecs>,
price: Option<&price::Vecs>,
exit: &Exit,
) -> color_eyre::Result<()> {
) -> Result<()> {
self.indexes_to_tx_count.compute_all(
indexer,
indexes,
@@ -731,7 +730,8 @@ impl Vecs {
&indexer.vecs.height_to_first_txindex,
&indexer.vecs.txindex_to_txid,
exit,
)
)?;
Ok(())
},
)?;
@@ -752,7 +752,7 @@ impl Vecs {
)?;
let compute_indexes_to_tx_vany =
|indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredUsize>, txversion| {
|indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredU64>, txversion| {
let mut txindex_to_txversion_iter = indexer.vecs.txindex_to_txversion.iter();
indexes_to_tx_vany.compute_all(
indexer,
@@ -769,7 +769,8 @@ impl Vecs {
v == txversion
},
exit,
)
)?;
Ok(())
},
)
};
@@ -863,7 +864,7 @@ impl Vecs {
starting_indexes,
exit,
Some(&self.txindex_to_fee),
fetched,
price,
)?;
self.indexes_to_feerate.compute_rest(
@@ -893,7 +894,7 @@ impl Vecs {
self.indexes_to_coinbase.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|vec, indexer, _, starting_indexes, exit| {
@@ -910,23 +911,23 @@ impl Vecs {
.unwrap_to_usize();
let output_count = txindex_to_output_count_iter.unwrap_get_inner(txindex);
let mut sats = Sats::ZERO;
(first_outputindex..first_outputindex + *output_count).for_each(
|outputindex| {
(first_outputindex..first_outputindex + usize::from(output_count))
.for_each(|outputindex| {
sats += outputindex_to_value_iter
.unwrap_get_inner(OutputIndex::from(outputindex));
},
);
});
(height, sats)
},
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_subsidy.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
@@ -940,14 +941,15 @@ impl Vecs {
(height, coinbase.checked_sub(fees).unwrap())
},
exit,
)
)?;
Ok(())
},
)?;
self.indexes_to_unclaimed_rewards.compute_all(
indexer,
indexes,
fetched,
price,
starting_indexes,
exit,
|vec, _, _, starting_indexes, exit| {
@@ -961,7 +963,8 @@ impl Vecs {
(height, expected.checked_sub(subsidy).unwrap())
},
exit,
)
)?;
Ok(())
},
)?;
@@ -976,7 +979,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2aaddressindex,
&indexer.vecs.p2aaddressindex_to_p2abytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -991,7 +995,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2msoutputindex,
&indexer.vecs.p2msoutputindex_to_txindex,
exit,
)
)?;
Ok(())
},
)?;
@@ -1006,7 +1011,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2pk33addressindex,
&indexer.vecs.p2pk33addressindex_to_p2pk33bytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -1021,7 +1027,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2pk65addressindex,
&indexer.vecs.p2pk65addressindex_to_p2pk65bytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -1036,7 +1043,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2pkhaddressindex,
&indexer.vecs.p2pkhaddressindex_to_p2pkhbytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -1051,7 +1059,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2shaddressindex,
&indexer.vecs.p2shaddressindex_to_p2shbytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -1066,7 +1075,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2traddressindex,
&indexer.vecs.p2traddressindex_to_p2trbytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -1081,7 +1091,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2wpkhaddressindex,
&indexer.vecs.p2wpkhaddressindex_to_p2wpkhbytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -1096,7 +1107,8 @@ impl Vecs {
&indexer.vecs.height_to_first_p2wshaddressindex,
&indexer.vecs.p2wshaddressindex_to_p2wshbytes,
exit,
)
)?;
Ok(())
},
)?;
@@ -1111,7 +1123,8 @@ impl Vecs {
&indexer.vecs.height_to_first_opreturnindex,
&indexer.vecs.opreturnindex_to_txindex,
exit,
)
)?;
Ok(())
},
)?;
@@ -1126,7 +1139,8 @@ impl Vecs {
&indexer.vecs.height_to_first_unknownoutputindex,
&indexer.vecs.unknownoutputindex_to_txindex,
exit,
)
)?;
Ok(())
},
)?;
@@ -1141,7 +1155,8 @@ impl Vecs {
&indexer.vecs.height_to_first_emptyoutputindex,
&indexer.vecs.emptyoutputindex_to_txindex,
exit,
)
)?;
Ok(())
},
)?;
@@ -1167,7 +1182,7 @@ impl Vecs {
|(h, output_count, ..)| {
let input_count = input_count_iter.unwrap_get_inner(h);
let opreturn_count = opreturn_count_iter.unwrap_get_inner(h);
let block_count = usize::from(h + 1_usize);
let block_count = u64::from(h + 1_usize);
// -1 > genesis output is unspendable
let mut utxo_count =
*output_count - (*input_count - block_count) - *opreturn_count - 1;
@@ -1190,13 +1205,16 @@ impl Vecs {
utxo_count -= 1;
}
(h, StoredUsize::from(utxo_count))
(h, StoredU64::from(utxo_count))
},
exit,
)
)?;
Ok(())
},
)?;
self.file.flush()?;
self.file.punch_holes()?;
Ok(())
}