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

global: snapshot

Browse Source
This commit is contained in:
nym21
2026-03-13 16:27:10 +01:00
parent b2a1251774
commit 3709ceff8e
168 changed files with 2007 additions and 2008 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,7 +13,7 @@ impl Vecs {
exit: &Exit,
) -> Result<()> {
// Block count raw + cumulative
self.total.raw.height.compute_range(
self.total.base.height.compute_range(
starting_indexes.height,
&indexer.vecs.blocks.weight,
|h| (h, StoredU32::from(1_u32)),

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, CachedWindowStarts, ComputedPerBlockCumulativeWithSums, ConstantVecs},
internal::{BlockCountTarget, CachedWindowStarts, PerBlockCumulativeWithSums, ConstantVecs},
};
impl Vecs {
@@ -21,7 +21,7 @@ impl Vecs {
version,
indexes,
),
total: ComputedPerBlockCumulativeWithSums::forced_import(
total: PerBlockCumulativeWithSums::forced_import(
db,
"block_count",
version + Version::ONE,

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

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

@@ -1,9 +1,8 @@
use brk_error::Result;
use brk_indexer::Indexer;
use brk_types::{Indexes, StoredF64, StoredU32};
use brk_types::{Indexes, StoredU32};
use vecdb::Exit;
use super::super::TARGET_BLOCKS_PER_DAY_F32;
use super::Vecs;
use crate::indexes;
@@ -15,18 +14,6 @@ impl Vecs {
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
// raw is fully lazy from indexer height source — no compute needed
// Compute difficulty as hash rate equivalent
let multiplier = 2.0_f64.powi(32) / 600.0;
self.as_hash.height.compute_transform(
starting_indexes.height,
&indexer.vecs.blocks.difficulty,
|(i, v, ..)| (i, StoredF64::from(*v * multiplier)),
exit,
)?;
// Compute difficulty adjustment ratio: (current - previous) / previous
self.adjustment.bps.height.compute_ratio_change(
starting_indexes.height,
&indexer.vecs.blocks.difficulty,
@@ -34,7 +21,6 @@ impl Vecs {
exit,
)?;
// Compute epoch by height
self.epoch.height.compute_transform(
starting_indexes.height,
&indexes.height.epoch,
@@ -42,21 +28,10 @@ impl Vecs {
exit,
)?;
// Compute blocks before next adjustment
self.blocks_before_next
.height
.compute_transform(
starting_indexes.height,
&indexes.height.identity,
|(h, ..)| (h, StoredU32::from(h.left_before_next_diff_adj())),
exit,
)?;
// Compute days before next adjustment
self.days_before_next.height.compute_transform(
self.blocks_before_next.height.compute_transform(
starting_indexes.height,
&self.blocks_before_next.height,
|(h, blocks, ..)| (h, (*blocks as f32 / TARGET_BLOCKS_PER_DAY_F32).into()),
&indexes.height.identity,
|(h, ..)| (h, StoredU32::from(h.left_before_next_diff_adj())),
exit,
)?;

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

@@ -6,7 +6,9 @@ use vecdb::{Database, ReadableCloneableVec};
use super::Vecs;
use crate::{
indexes,
internal::{ComputedPerBlock, Resolutions, PercentPerBlock},
internal::{
BlocksToDaysF32, DifficultyToHashF64, LazyPerBlock, PerBlock, PercentPerBlock, Resolutions,
},
};
impl Vecs {
@@ -18,33 +20,39 @@ impl Vecs {
) -> Result<Self> {
let v2 = Version::TWO;
let as_hash = LazyPerBlock::from_height_source::<DifficultyToHashF64>(
"difficulty_as_hash",
version,
indexer.vecs.blocks.difficulty.read_only_boxed_clone(),
indexes,
);
let blocks_before_next = PerBlock::forced_import(
db,
"blocks_before_next_difficulty_adjustment",
version + v2,
indexes,
)?;
let days_before_next = LazyPerBlock::from_computed::<BlocksToDaysF32>(
"days_before_next_difficulty_adjustment",
version + v2,
blocks_before_next.height.read_only_boxed_clone(),
&blocks_before_next,
);
Ok(Self {
raw: Resolutions::forced_import(
base: Resolutions::forced_import(
"difficulty",
indexer.vecs.blocks.difficulty.read_only_boxed_clone(),
version,
indexes,
),
as_hash: ComputedPerBlock::forced_import(db, "difficulty_as_hash", version, indexes)?,
adjustment: PercentPerBlock::forced_import(
db,
"difficulty_adjustment",
version,
indexes,
)?,
epoch: ComputedPerBlock::forced_import(db, "difficulty_epoch", version, indexes)?,
blocks_before_next: ComputedPerBlock::forced_import(
db,
"blocks_before_next_difficulty_adjustment",
version + v2,
indexes,
)?,
days_before_next: ComputedPerBlock::forced_import(
db,
"days_before_next_difficulty_adjustment",
version + v2,
indexes,
)?,
as_hash,
adjustment: PercentPerBlock::forced_import(db, "difficulty_adjustment", version, indexes)?,
epoch: PerBlock::forced_import(db, "difficulty_epoch", version, indexes)?,
blocks_before_next,
days_before_next,
})
}
}

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

@@ -2,13 +2,13 @@ use brk_traversable::Traversable;
use brk_types::{BasisPointsSigned32, Epoch, StoredF32, StoredF64, StoredU32};
use vecdb::{Rw, StorageMode};
use crate::internal::{ComputedPerBlock, Resolutions, PercentPerBlock};
use crate::internal::{LazyPerBlock, PerBlock, Resolutions, PercentPerBlock};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub raw: Resolutions<StoredF64>,
pub as_hash: ComputedPerBlock<StoredF64, M>,
pub base: Resolutions<StoredF64>,
pub as_hash: LazyPerBlock<StoredF64>,
pub adjustment: PercentPerBlock<BasisPointsSigned32, M>,
pub epoch: ComputedPerBlock<Epoch, M>,
pub blocks_before_next: ComputedPerBlock<StoredU32, M>,
pub days_before_next: ComputedPerBlock<StoredF32, M>,
pub epoch: PerBlock<Epoch, M>,
pub blocks_before_next: PerBlock<StoredU32, M>,
pub days_before_next: LazyPerBlock<StoredF32, StoredU32>,
}

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

@@ -2,7 +2,6 @@ use brk_error::Result;
use brk_types::{Indexes, StoredU32};
use vecdb::Exit;
use super::super::TARGET_BLOCKS_PER_DAY_F32;
use super::Vecs;
use crate::indexes;
@@ -27,13 +26,6 @@ impl Vecs {
exit,
)?;
self.days_before_next.height.compute_transform(
starting_indexes.height,
&self.blocks_before_next.height,
|(h, blocks, ..)| (h, (*blocks as f32 / TARGET_BLOCKS_PER_DAY_F32).into()),
exit,
)?;
Ok(())
}
}

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

@@ -1,9 +1,12 @@
use brk_error::Result;
use brk_types::Version;
use vecdb::Database;
use vecdb::{Database, ReadableCloneableVec};
use super::Vecs;
use crate::{indexes, internal::ComputedPerBlock};
use crate::{
indexes,
internal::{BlocksToDaysF32, LazyPerBlock, PerBlock},
};
impl Vecs {
pub(crate) fn forced_import(
@@ -13,20 +16,21 @@ impl Vecs {
) -> Result<Self> {
let v2 = Version::TWO;
let blocks_before_next = PerBlock::forced_import(
db, "blocks_before_next_halving", version + v2, indexes,
)?;
let days_before_next = LazyPerBlock::from_computed::<BlocksToDaysF32>(
"days_before_next_halving",
version + v2,
blocks_before_next.height.read_only_boxed_clone(),
&blocks_before_next,
);
Ok(Self {
epoch: ComputedPerBlock::forced_import(db, "halving_epoch", version, indexes)?,
blocks_before_next: ComputedPerBlock::forced_import(
db,
"blocks_before_next_halving",
version + v2,
indexes,
)?,
days_before_next: ComputedPerBlock::forced_import(
db,
"days_before_next_halving",
version + v2,
indexes,
)?,
epoch: PerBlock::forced_import(db, "halving_epoch", version, indexes)?,
blocks_before_next,
days_before_next,
})
}
}

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

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

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

@@ -6,7 +6,7 @@ use brk_types::Version;
use crate::{
indexes,
internal::{finalize_db, open_db},
internal::db_utils::{finalize_db, open_db},
};
use super::{

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::{CachedWindowStarts, ComputedPerBlockRollingAverage}};
use crate::{indexes, internal::{CachedWindowStarts, PerBlockRollingAverage}};
impl Vecs {
pub(crate) fn forced_import(
@@ -12,7 +12,7 @@ impl Vecs {
indexes: &indexes::Vecs,
cached_starts: &CachedWindowStarts,
) -> Result<Self> {
let interval = ComputedPerBlockRollingAverage::forced_import(
let interval = PerBlockRollingAverage::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::ComputedPerBlockRollingAverage;
use crate::internal::PerBlockRollingAverage;
#[derive(Deref, DerefMut, Traversable)]
pub struct Vecs<M: StorageMode = Rw>(
#[traversable(flatten)] pub ComputedPerBlockRollingAverage<Timestamp, M>,
#[traversable(flatten)] pub PerBlockRollingAverage<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::{CachedWindowStarts, ComputedPerBlockFull, ResolutionsFull},
internal::{CachedWindowStarts, PerBlockFull, PerBlockRolling},
};
impl Vecs {
@@ -16,14 +16,14 @@ impl Vecs {
cached_starts: &CachedWindowStarts,
) -> Result<Self> {
Ok(Self {
vbytes: ComputedPerBlockFull::forced_import(
vbytes: PerBlockFull::forced_import(
db,
"block_vbytes",
version,
indexes,
cached_starts,
)?,
size: ResolutionsFull::forced_import(
size: PerBlockRolling::forced_import(
db,
"block_size",
version,

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::{ComputedPerBlockFull, ResolutionsFull};
use crate::internal::{PerBlockFull, PerBlockRolling};
#[derive(Traversable)]
pub struct Vecs<M: StorageMode = Rw> {
pub vbytes: ComputedPerBlockFull<StoredU64, M>,
pub size: ResolutionsFull<StoredU64, M>,
pub vbytes: PerBlockFull<StoredU64, M>,
pub size: PerBlockRolling<StoredU64, M>,
}

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

@@ -6,7 +6,7 @@ use super::Vecs;
use crate::{
blocks::SizeVecs,
indexes,
internal::{CachedWindowStarts, LazyResolutionsFull, PercentPerBlockRollingAverage, VBytesToWeight},
internal::{CachedWindowStarts, LazyPerBlockRolling, PercentPerBlockRollingAverage, VBytesToWeight},
};
impl Vecs {
@@ -17,7 +17,7 @@ impl Vecs {
cached_starts: &CachedWindowStarts,
size: &SizeVecs,
) -> Result<Self> {
let weight = LazyResolutionsFull::from_computed_per_block_full::<VBytesToWeight>(
let weight = LazyPerBlockRolling::from_per_block_full::<VBytesToWeight>(
"block_weight",
version,
&size.vbytes,

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

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