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

global: big snapshot

Browse Source
This commit is contained in:
nym21
2026-03-13 12:47:01 +01:00
parent c83955eea7
commit 2b31c7f6b7
158 changed files with 4961 additions and 6939 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
crates/brk_computer/src/blocks/compute.rs
View File

@@ -21,9 +21,9 @@ impl Vecs {
self.lookback
.compute(&self.time, starting_indexes, exit)?;
self.count
.compute(indexer, &self.lookback, starting_indexes, exit)?;
.compute(indexer, starting_indexes, exit)?;
self.interval
.compute(indexer, &self.lookback, starting_indexes, exit)?;
.compute(indexer, starting_indexes, exit)?;
self.size
.compute(indexer, &self.lookback, starting_indexes, exit)?;
self.weight

18
crates/brk_computer/src/blocks/count/compute.rs
View File

@@ -5,13 +5,10 @@ use vecdb::Exit;
use super::Vecs;
use crate::blocks::lookback;
impl Vecs {
pub(crate) fn compute(
&mut self,
indexer: &Indexer,
lookback: &lookback::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
@@ -22,20 +19,7 @@ impl Vecs {
|h| (h, StoredU32::from(1_u32)),
exit,
)?;
self.total.cumulative.height.compute_cumulative(
starting_indexes.height,
&self.total.raw.height,
exit,
)?;
// Rolling window block counts
let ws = lookback.window_starts();
self.total.sum.compute_rolling_sum(
starting_indexes.height,
&ws,
&self.total.raw.height,
exit,
)?;
self.total.compute_rest(starting_indexes.height, exit)?;
Ok(())
}

6
crates/brk_computer/src/blocks/count/import.rs
View File

@@ -5,7 +5,7 @@ use vecdb::Database;
use super::Vecs;
use crate::{
indexes,
internal::{BlockCountTarget, ComputedPerBlockCumulativeSum, ConstantVecs},
internal::{BlockCountTarget, CachedWindowStarts, ComputedPerBlockCumulativeWithSums, ConstantVecs},
};
impl Vecs {
@@ -13,6 +13,7 @@ impl Vecs {
db: &Database,
version: Version,
indexes: &indexes::Vecs,
cached_starts: &CachedWindowStarts,
) -> Result<Self> {
Ok(Self {
target: ConstantVecs::new::<BlockCountTarget>(
@@ -20,11 +21,12 @@ impl Vecs {
version,
indexes,
),
total: ComputedPerBlockCumulativeSum::forced_import(
total: ComputedPerBlockCumulativeWithSums::forced_import(
db,
"block_count",
version,
indexes,
cached_starts,
)?,
})
}

4
crates/brk_computer/src/blocks/count/vecs.rs
View File

@@ -2,10 +2,10 @@ use brk_traversable::Traversable;
use brk_types::{StoredU32, StoredU64};
use vecdb::{Rw, StorageMode};
use crate::internal::{ComputedPerBlockCumulativeSum, ConstantVecs};
use crate::internal::{ComputedPerBlockCumulativeWithSums, ConstantVecs};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub target: ConstantVecs<StoredU64>,
pub total: ComputedPerBlockCumulativeSum<StoredU32, M>,
pub total: ComputedPerBlockCumulativeWithSums<StoredU32, StoredU64, M>,
}

9
crates/brk_computer/src/blocks/import.rs
View File

@@ -24,11 +24,12 @@ impl Vecs {
let db = open_db(parent_path, super::DB_NAME, 50_000_000)?;
let version = parent_version;
let count = CountVecs::forced_import(&db, version, indexes)?;
let lookback = LookbackVecs::forced_import(&db, version)?;
let interval = IntervalVecs::forced_import(&db, version, indexes)?;
let size = SizeVecs::forced_import(&db, version, indexes)?;
let weight = WeightVecs::forced_import(&db, version, indexes)?;
let cached_starts = &lookback.cached_window_starts;
let count = CountVecs::forced_import(&db, version, indexes, cached_starts)?;
let interval = IntervalVecs::forced_import(&db, version, indexes, cached_starts)?;
let size = SizeVecs::forced_import(&db, version, indexes, cached_starts)?;
let weight = WeightVecs::forced_import(&db, version, indexes, cached_starts)?;
let time = TimeVecs::forced_import(&db, version, indexes)?;
let difficulty = DifficultyVecs::forced_import(&db, version, indexer, indexes)?;
let halving = HalvingVecs::forced_import(&db, version, indexes)?;

5
crates/brk_computer/src/blocks/interval/compute.rs
View File

@@ -4,20 +4,17 @@ use brk_types::{CheckedSub, Indexes, Timestamp};
use vecdb::{Exit, ReadableVec};
use super::Vecs;
use crate::blocks;
impl Vecs {
pub(crate) fn compute(
&mut self,
indexer: &Indexer,
lookback: &blocks::LookbackVecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
let mut prev_timestamp = None;
let window_starts = lookback.window_starts();
self.0
.compute(starting_indexes.height, &window_starts, exit, |vec| {
.compute(starting_indexes.height, exit, |vec| {
vec.compute_transform(
starting_indexes.height,
&indexer.vecs.blocks.timestamp,

4
crates/brk_computer/src/blocks/interval/import.rs
View File

@@ -3,19 +3,21 @@ use brk_types::Version;
use vecdb::Database;
use super::Vecs;
use crate::{indexes, internal::ComputedPerBlockRollingAverage};
use crate::{indexes, internal::{CachedWindowStarts, ComputedPerBlockRollingAverage}};
impl Vecs {
pub(crate) fn forced_import(
db: &Database,
version: Version,
indexes: &indexes::Vecs,
cached_starts: &CachedWindowStarts,
) -> Result<Self> {
let interval = ComputedPerBlockRollingAverage::forced_import(
db,
"block_interval",
version,
indexes,
cached_starts,
)?;
Ok(Self(interval))

106
crates/brk_computer/src/blocks/lookback.rs
View File

@@ -1,14 +1,16 @@
use brk_error::Result;
use brk_traversable::Traversable;
use brk_types::{Height, Indexes, Timestamp, Version};
use vecdb::{AnyVec, Cursor, Database, EagerVec, Exit, ImportableVec, PcoVec, ReadableVec, Rw, StorageMode, VecIndex};
use vecdb::{AnyVec, CachedVec, Cursor, Database, EagerVec, Exit, ImportableVec, PcoVec, ReadableVec, Rw, StorageMode, VecIndex};
use crate::internal::WindowStarts;
use crate::internal::{CachedWindowStarts, Windows, WindowStarts};
use super::time;
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
#[traversable(skip)]
pub cached_window_starts: CachedWindowStarts,
pub _1h: M::Stored<EagerVec<PcoVec<Height, Height>>>,
pub _24h: M::Stored<EagerVec<PcoVec<Height, Height>>>, // 1d
pub _3d: M::Stored<EagerVec<PcoVec<Height, Height>>>,
@@ -56,50 +58,63 @@ pub struct Vecs<M: StorageMode = Rw> {
impl Vecs {
pub(crate) fn forced_import(db: &Database, version: Version) -> Result<Self> {
let _1h = ImportableVec::forced_import(db, "height_1h_ago", version)?;
let _24h = ImportableVec::forced_import(db, "height_24h_ago", version)?;
let _3d = ImportableVec::forced_import(db, "height_3d_ago", version)?;
let _1w = ImportableVec::forced_import(db, "height_1w_ago", version)?;
let _8d = ImportableVec::forced_import(db, "height_8d_ago", version)?;
let _9d = ImportableVec::forced_import(db, "height_9d_ago", version)?;
let _12d = ImportableVec::forced_import(db, "height_12d_ago", version)?;
let _13d = ImportableVec::forced_import(db, "height_13d_ago", version)?;
let _2w = ImportableVec::forced_import(db, "height_2w_ago", version)?;
let _21d = ImportableVec::forced_import(db, "height_21d_ago", version)?;
let _26d = ImportableVec::forced_import(db, "height_26d_ago", version)?;
let _1m = ImportableVec::forced_import(db, "height_1m_ago", version)?;
let _34d = ImportableVec::forced_import(db, "height_34d_ago", version)?;
let _55d = ImportableVec::forced_import(db, "height_55d_ago", version)?;
let _2m = ImportableVec::forced_import(db, "height_2m_ago", version)?;
let _9w = ImportableVec::forced_import(db, "height_9w_ago", version)?;
let _12w = ImportableVec::forced_import(db, "height_12w_ago", version)?;
let _89d = ImportableVec::forced_import(db, "height_89d_ago", version)?;
let _3m = ImportableVec::forced_import(db, "height_3m_ago", version)?;
let _14w = ImportableVec::forced_import(db, "height_14w_ago", version)?;
let _111d = ImportableVec::forced_import(db, "height_111d_ago", version)?;
let _144d = ImportableVec::forced_import(db, "height_144d_ago", version)?;
let _6m = ImportableVec::forced_import(db, "height_6m_ago", version)?;
let _26w = ImportableVec::forced_import(db, "height_26w_ago", version)?;
let _200d = ImportableVec::forced_import(db, "height_200d_ago", version)?;
let _9m = ImportableVec::forced_import(db, "height_9m_ago", version)?;
let _350d = ImportableVec::forced_import(db, "height_350d_ago", version)?;
let _12m = ImportableVec::forced_import(db, "height_12m_ago", version)?;
let _1y = ImportableVec::forced_import(db, "height_1y_ago", version)?;
let _14m = ImportableVec::forced_import(db, "height_14m_ago", version)?;
let _2y = ImportableVec::forced_import(db, "height_2y_ago", version)?;
let _26m = ImportableVec::forced_import(db, "height_26m_ago", version)?;
let _3y = ImportableVec::forced_import(db, "height_3y_ago", version)?;
let _200w = ImportableVec::forced_import(db, "height_200w_ago", version)?;
let _4y = ImportableVec::forced_import(db, "height_4y_ago", version)?;
let _5y = ImportableVec::forced_import(db, "height_5y_ago", version)?;
let _6y = ImportableVec::forced_import(db, "height_6y_ago", version)?;
let _8y = ImportableVec::forced_import(db, "height_8y_ago", version)?;
let _9y = ImportableVec::forced_import(db, "height_9y_ago", version)?;
let _10y = ImportableVec::forced_import(db, "height_10y_ago", version)?;
let _12y = ImportableVec::forced_import(db, "height_12y_ago", version)?;
let _14y = ImportableVec::forced_import(db, "height_14y_ago", version)?;
let _26y = ImportableVec::forced_import(db, "height_26y_ago", version)?;
let cached_window_starts = CachedWindowStarts(Windows {
_24h: CachedVec::new(&_24h),
_1w: CachedVec::new(&_1w),
_1m: CachedVec::new(&_1m),
_1y: CachedVec::new(&_1y),
});
Ok(Self {
_1h: ImportableVec::forced_import(db, "height_1h_ago", version)?,
_24h: ImportableVec::forced_import(db, "height_24h_ago", version)?,
_3d: ImportableVec::forced_import(db, "height_3d_ago", version)?,
_1w: ImportableVec::forced_import(db, "height_1w_ago", version)?,
_8d: ImportableVec::forced_import(db, "height_8d_ago", version)?,
_9d: ImportableVec::forced_import(db, "height_9d_ago", version)?,
_12d: ImportableVec::forced_import(db, "height_12d_ago", version)?,
_13d: ImportableVec::forced_import(db, "height_13d_ago", version)?,
_2w: ImportableVec::forced_import(db, "height_2w_ago", version)?,
_21d: ImportableVec::forced_import(db, "height_21d_ago", version)?,
_26d: ImportableVec::forced_import(db, "height_26d_ago", version)?,
_1m: ImportableVec::forced_import(db, "height_1m_ago", version)?,
_34d: ImportableVec::forced_import(db, "height_34d_ago", version)?,
_55d: ImportableVec::forced_import(db, "height_55d_ago", version)?,
_2m: ImportableVec::forced_import(db, "height_2m_ago", version)?,
_9w: ImportableVec::forced_import(db, "height_9w_ago", version)?,
_12w: ImportableVec::forced_import(db, "height_12w_ago", version)?,
_89d: ImportableVec::forced_import(db, "height_89d_ago", version)?,
_3m: ImportableVec::forced_import(db, "height_3m_ago", version)?,
_14w: ImportableVec::forced_import(db, "height_14w_ago", version)?,
_111d: ImportableVec::forced_import(db, "height_111d_ago", version)?,
_144d: ImportableVec::forced_import(db, "height_144d_ago", version)?,
_6m: ImportableVec::forced_import(db, "height_6m_ago", version)?,
_26w: ImportableVec::forced_import(db, "height_26w_ago", version)?,
_200d: ImportableVec::forced_import(db, "height_200d_ago", version)?,
_9m: ImportableVec::forced_import(db, "height_9m_ago", version)?,
_350d: ImportableVec::forced_import(db, "height_350d_ago", version)?,
_12m: ImportableVec::forced_import(db, "height_12m_ago", version)?,
_1y: ImportableVec::forced_import(db, "height_1y_ago", version)?,
_14m: ImportableVec::forced_import(db, "height_14m_ago", version)?,
_2y: ImportableVec::forced_import(db, "height_2y_ago", version)?,
_26m: ImportableVec::forced_import(db, "height_26m_ago", version)?,
_3y: ImportableVec::forced_import(db, "height_3y_ago", version)?,
_200w: ImportableVec::forced_import(db, "height_200w_ago", version)?,
_4y: ImportableVec::forced_import(db, "height_4y_ago", version)?,
_5y: ImportableVec::forced_import(db, "height_5y_ago", version)?,
_6y: ImportableVec::forced_import(db, "height_6y_ago", version)?,
_8y: ImportableVec::forced_import(db, "height_8y_ago", version)?,
_9y: ImportableVec::forced_import(db, "height_9y_ago", version)?,
_10y: ImportableVec::forced_import(db, "height_10y_ago", version)?,
_12y: ImportableVec::forced_import(db, "height_12y_ago", version)?,
_14y: ImportableVec::forced_import(db, "height_14y_ago", version)?,
_26y: ImportableVec::forced_import(db, "height_26y_ago", version)?,
cached_window_starts,
_1h, _24h, _3d, _1w, _8d, _9d, _12d, _13d, _2w, _21d, _26d,
_1m, _34d, _55d, _2m, _9w, _12w, _89d, _3m, _14w, _111d, _144d,
_6m, _26w, _200d, _9m, _350d, _12m, _1y, _14m, _2y, _26m, _3y,
_200w, _4y, _5y, _6y, _8y, _9y, _10y, _12y, _14y, _26y,
})
}
@@ -112,6 +127,7 @@ impl Vecs {
}
}
pub fn start_vec(&self, days: usize) -> &EagerVec<PcoVec<Height, Height>> {
match days {
1 => &self._24h,

19
crates/brk_computer/src/blocks/size/import.rs
View File

@@ -5,7 +5,7 @@ use vecdb::Database;
use super::Vecs;
use crate::{
indexes,
internal::{ComputedPerBlockFull, ResolutionsFull},
internal::{CachedWindowStarts, ComputedPerBlockFull, ResolutionsFull},
};
impl Vecs {
@@ -13,10 +13,23 @@ impl Vecs {
db: &Database,
version: Version,
indexes: &indexes::Vecs,
cached_starts: &CachedWindowStarts,
) -> Result<Self> {
Ok(Self {
vbytes: ComputedPerBlockFull::forced_import(db, "block_vbytes", version, indexes)?,
size: ResolutionsFull::forced_import(db, "block_size", version, indexes)?,
vbytes: ComputedPerBlockFull::forced_import(
db,
"block_vbytes",
version,
indexes,
cached_starts,
)?,
size: ResolutionsFull::forced_import(
db,
"block_size",
version,
indexes,
cached_starts,
)?,
})
}
}

2
crates/brk_computer/src/blocks/weight/compute.rs
View File

@@ -24,7 +24,7 @@ impl Vecs {
)?;
self.fullness
.compute(starting_indexes.height, &window_starts, exit, |vec| {
.compute(starting_indexes.height, exit, |vec| {
vec.compute_transform(
starting_indexes.height,
&indexer.vecs.blocks.weight,

6
crates/brk_computer/src/blocks/weight/import.rs
View File

@@ -5,7 +5,7 @@ use vecdb::Database;
use super::Vecs;
use crate::{
indexes,
internal::{ResolutionsFull, PercentPerBlockRollingAverage},
internal::{CachedWindowStarts, ResolutionsFull, PercentPerBlockRollingAverage},
};
impl Vecs {
@@ -13,15 +13,17 @@ impl Vecs {
db: &Database,
version: Version,
indexes: &indexes::Vecs,
cached_starts: &CachedWindowStarts,
) -> Result<Self> {
let weight =
ResolutionsFull::forced_import(db, "block_weight", version, indexes)?;
ResolutionsFull::forced_import(db, "block_weight", version, indexes, cached_starts)?;
let fullness = PercentPerBlockRollingAverage::forced_import(
db,
"block_fullness",
version,
indexes,
cached_starts,
)?;
Ok(Self { weight, fullness })