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

computer: snapshot

Browse Source
This commit is contained in:
nym21
2026-03-09 14:27:35 +01:00
parent e4bd11317a
commit cba3b7dc38
178 changed files with 1089 additions and 1089 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
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, ComputedFromHeightCumulativeSum, ConstantVecs},
internal::{BlockCountTarget, ComputedPerBlockCumulativeSum, ConstantVecs},
};
impl Vecs {
@@ -20,7 +20,7 @@ impl Vecs {
version,
indexes,
),
block_count: ComputedFromHeightCumulativeSum::forced_import(
block_count: ComputedPerBlockCumulativeSum::forced_import(
db,
"block_count",
version,

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::{ComputedFromHeightCumulativeSum, ConstantVecs};
use crate::internal::{ComputedPerBlockCumulativeSum, ConstantVecs};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub block_count_target: ConstantVecs<StoredU64>,
pub block_count: ComputedFromHeightCumulativeSum<StoredU32, M>,
pub block_count: ComputedPerBlockCumulativeSum<StoredU32, M>,
}

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

@@ -37,7 +37,7 @@ impl Vecs {
// Compute epoch by height
self.epoch.height.compute_transform(
starting_indexes.height,
&indexes.height.difficultyepoch,
&indexes.height.difficulty,
|(h, epoch, ..)| (h, epoch),
exit,
)?;

14
crates/brk_computer/src/blocks/difficulty/import.rs
View File

@@ -6,7 +6,7 @@ use vecdb::{Database, ReadableCloneableVec};
use super::Vecs;
use crate::{
indexes,
internal::{ComputedFromHeight, ComputedHeightDerived, PercentFromHeight},
internal::{ComputedPerBlock, Resolutions, PercentPerBlock},
};
impl Vecs {
@@ -19,27 +19,27 @@ impl Vecs {
let v2 = Version::TWO;
Ok(Self {
raw: ComputedHeightDerived::forced_import(
raw: Resolutions::forced_import(
"difficulty",
indexer.vecs.blocks.difficulty.read_only_boxed_clone(),
version,
indexes,
),
as_hash: ComputedFromHeight::forced_import(db, "difficulty_as_hash", version, indexes)?,
adjustment: PercentFromHeight::forced_import(
as_hash: ComputedPerBlock::forced_import(db, "difficulty_as_hash", version, indexes)?,
adjustment: PercentPerBlock::forced_import(
db,
"difficulty_adjustment",
version,
indexes,
)?,
epoch: ComputedFromHeight::forced_import(db, "difficulty_epoch", version, indexes)?,
blocks_before_next_adjustment: ComputedFromHeight::forced_import(
epoch: ComputedPerBlock::forced_import(db, "difficulty_epoch", version, indexes)?,
blocks_before_next_adjustment: ComputedPerBlock::forced_import(
db,
"blocks_before_next_difficulty_adjustment",
version + v2,
indexes,
)?,
days_before_next_adjustment: ComputedFromHeight::forced_import(
days_before_next_adjustment: ComputedPerBlock::forced_import(
db,
"days_before_next_difficulty_adjustment",
version + v2,

14
crates/brk_computer/src/blocks/difficulty/vecs.rs
View File

@@ -2,13 +2,13 @@ use brk_traversable::Traversable;
use brk_types::{BasisPointsSigned32, DifficultyEpoch, StoredF32, StoredF64, StoredU32};
use vecdb::{Rw, StorageMode};
use crate::internal::{ComputedFromHeight, ComputedHeightDerived, PercentFromHeight};
use crate::internal::{ComputedPerBlock, Resolutions, PercentPerBlock};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub raw: ComputedHeightDerived<StoredF64>,
pub as_hash: ComputedFromHeight<StoredF64, M>,
pub adjustment: PercentFromHeight<BasisPointsSigned32, M>,
pub epoch: ComputedFromHeight<DifficultyEpoch, M>,
pub blocks_before_next_adjustment: ComputedFromHeight<StoredU32, M>,
pub days_before_next_adjustment: ComputedFromHeight<StoredF32, M>,
pub raw: Resolutions<StoredF64>,
pub as_hash: ComputedPerBlock<StoredF64, M>,
pub adjustment: PercentPerBlock<BasisPointsSigned32, M>,
pub epoch: ComputedPerBlock<DifficultyEpoch, M>,
pub blocks_before_next_adjustment: ComputedPerBlock<StoredU32, M>,
pub days_before_next_adjustment: ComputedPerBlock<StoredF32, M>,
}

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

@@ -15,7 +15,7 @@ impl Vecs {
) -> Result<()> {
self.epoch.height.compute_transform(
starting_indexes.height,
&indexes.height.halvingepoch,
&indexes.height.halving,
|(h, epoch, ..)| (h, epoch),
exit,
)?;

8
crates/brk_computer/src/blocks/halving/import.rs
View File

@@ -3,7 +3,7 @@ use brk_types::Version;
use vecdb::Database;
use super::Vecs;
use crate::{indexes, internal::ComputedFromHeight};
use crate::{indexes, internal::ComputedPerBlock};
impl Vecs {
pub(crate) fn forced_import(
@@ -14,14 +14,14 @@ impl Vecs {
let v2 = Version::TWO;
Ok(Self {
epoch: ComputedFromHeight::forced_import(db, "halving_epoch", version, indexes)?,
blocks_before_next_halving: ComputedFromHeight::forced_import(
epoch: ComputedPerBlock::forced_import(db, "halving_epoch", version, indexes)?,
blocks_before_next_halving: ComputedPerBlock::forced_import(
db,
"blocks_before_next_halving",
version + v2,
indexes,
)?,
days_before_next_halving: ComputedFromHeight::forced_import(
days_before_next_halving: ComputedPerBlock::forced_import(
db,
"days_before_next_halving",
version + v2,

8
crates/brk_computer/src/blocks/halving/vecs.rs
View File

@@ -2,10 +2,10 @@ use brk_traversable::Traversable;
use brk_types::{HalvingEpoch, StoredF32, StoredU32};
use vecdb::{Rw, StorageMode};
use crate::internal::ComputedFromHeight;
use crate::internal::ComputedPerBlock;
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub epoch: ComputedFromHeight<HalvingEpoch, M>,
pub blocks_before_next_halving: ComputedFromHeight<StoredU32, M>,
pub days_before_next_halving: ComputedFromHeight<StoredF32, M>,
pub epoch: ComputedPerBlock<HalvingEpoch, M>,
pub blocks_before_next_halving: ComputedPerBlock<StoredU32, M>,
pub days_before_next_halving: ComputedPerBlock<StoredF32, M>,
}

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

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

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

@@ -4,9 +4,9 @@ use brk_traversable::Traversable;
use brk_types::Timestamp;
use vecdb::{Rw, StorageMode};
use crate::internal::ComputedFromHeightRollingAverage;
use crate::internal::ComputedPerBlockRollingAverage;
#[derive(Deref, DerefMut, Traversable)]
pub struct Vecs<M: StorageMode = Rw>(
#[traversable(flatten)] pub ComputedFromHeightRollingAverage<Timestamp, M>,
#[traversable(flatten)] pub ComputedPerBlockRollingAverage<Timestamp, M>,
);

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

@@ -5,7 +5,7 @@ use vecdb::Database;
use super::Vecs;
use crate::{
indexes,
internal::{ComputedFromHeightFull, ComputedHeightDerivedFull},
internal::{ComputedPerBlockFull, ResolutionsFull},
};
impl Vecs {
@@ -15,8 +15,8 @@ impl Vecs {
indexes: &indexes::Vecs,
) -> Result<Self> {
Ok(Self {
vbytes: ComputedFromHeightFull::forced_import(db, "block_vbytes", version, indexes)?,
size: ComputedHeightDerivedFull::forced_import(db, "block_size", version, indexes)?,
vbytes: ComputedPerBlockFull::forced_import(db, "block_vbytes", version, indexes)?,
size: ResolutionsFull::forced_import(db, "block_size", version, indexes)?,
})
}
}

6
crates/brk_computer/src/blocks/size/vecs.rs
View File

@@ -2,10 +2,10 @@ use brk_traversable::Traversable;
use brk_types::StoredU64;
use vecdb::{Rw, StorageMode};
use crate::internal::{ComputedFromHeightFull, ComputedHeightDerivedFull};
use crate::internal::{ComputedPerBlockFull, ResolutionsFull};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub vbytes: ComputedFromHeightFull<StoredU64, M>,
pub size: ComputedHeightDerivedFull<StoredU64, M>,
pub vbytes: ComputedPerBlockFull<StoredU64, M>,
pub size: ResolutionsFull<StoredU64, M>,
}

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

@@ -45,7 +45,7 @@ impl TimestampIndexes {
};
}
Ok(Self(crate::internal::PerPeriod {
Ok(Self(crate::internal::PerResolution {
minute10: period!(minute10),
minute30: period!(minute30),
hour1: period!(hour1),
@@ -59,8 +59,8 @@ impl TimestampIndexes {
month6: period!(month6),
year1: period!(year1),
year10: period!(year10),
halvingepoch: epoch!(halvingepoch),
difficultyepoch: epoch!(difficultyepoch),
halving: epoch!(halving),
difficulty: epoch!(difficulty),
}))
}
}

18
crates/brk_computer/src/blocks/time/vecs.rs
View File

@@ -7,7 +7,7 @@ use brk_types::{
use derive_more::{Deref, DerefMut};
use vecdb::{EagerVec, Exit, LazyVecFrom1, PcoVec, ReadableVec, Rw, StorageMode};
use crate::{indexes, internal::PerPeriod};
use crate::{indexes, internal::PerResolution};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub date: LazyVecFrom1<Height, Date, Height, Timestamp>,
@@ -19,13 +19,13 @@ pub struct Vecs<M: StorageMode = Rw> {
///
/// Time-based periods (minute10–year10) are lazy: `idx.to_timestamp()` is a pure
/// function of the index, so no storage or decompression is needed.
/// Epoch-based periods (halvingepoch, difficultyepoch) are eager: their timestamps
/// Epoch-based periods (halving, difficulty) are eager: their timestamps
/// come from block data via `compute_indirect_sequential`.
#[derive(Deref, DerefMut, Traversable)]
#[traversable(transparent)]
pub struct TimestampIndexes<M: StorageMode = Rw>(
#[allow(clippy::type_complexity)]
pub PerPeriod<
pub PerResolution<
LazyVecFrom1<Minute10, Timestamp, Minute10, Height>,
LazyVecFrom1<Minute30, Timestamp, Minute30, Height>,
LazyVecFrom1<Hour1, Timestamp, Hour1, Height>,
@@ -55,23 +55,23 @@ impl TimestampIndexes {
exit: &Exit,
) -> Result<()> {
let prev_height = starting_indexes.height.decremented().unwrap_or_default();
self.halvingepoch.compute_indirect_sequential(
self.halving.compute_indirect_sequential(
indexes
.height
.halvingepoch
.halving
.collect_one(prev_height)
.unwrap_or_default(),
&indexes.halvingepoch.first_height,
&indexes.halving.first_height,
&indexer.vecs.blocks.timestamp,
exit,
)?;
self.difficultyepoch.compute_indirect_sequential(
self.difficulty.compute_indirect_sequential(
indexes
.height
.difficultyepoch
.difficulty
.collect_one(prev_height)
.unwrap_or_default(),
&indexes.difficultyepoch.first_height,
&indexes.difficulty.first_height,
&indexer.vecs.blocks.timestamp,
exit,
)?;

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::{ComputedHeightDerivedFull, PercentFromHeightRollingAverage},
internal::{ResolutionsFull, PercentPerBlockRollingAverage},
};
impl Vecs {
@@ -15,9 +15,9 @@ impl Vecs {
indexes: &indexes::Vecs,
) -> Result<Self> {
let weight =
ComputedHeightDerivedFull::forced_import(db, "block_weight", version, indexes)?;
ResolutionsFull::forced_import(db, "block_weight", version, indexes)?;
let fullness = PercentFromHeightRollingAverage::forced_import(
let fullness = PercentPerBlockRollingAverage::forced_import(
db,
"block_fullness",
version,

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

@@ -2,10 +2,10 @@ use brk_traversable::Traversable;
use brk_types::{BasisPoints16, Weight};
use vecdb::{Rw, StorageMode};
use crate::internal::{ComputedHeightDerivedFull, PercentFromHeightRollingAverage};
use crate::internal::{ResolutionsFull, PercentPerBlockRollingAverage};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub weight: ComputedHeightDerivedFull<Weight, M>,
pub fullness: PercentFromHeightRollingAverage<BasisPoints16, M>,
pub weight: ResolutionsFull<Weight, M>,
pub fullness: PercentPerBlockRollingAverage<BasisPoints16, M>,
}