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

global: snapshot

Browse Source
This commit is contained in:
nym21
2025-11-08 14:43:23 +01:00
parent 3d3787a8d9
commit e77fe0253e
69 changed files with 696 additions and 647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
crates/brk_computer/src/chain.rs
View File

@@ -1,6 +1,5 @@
use std::path::Path;
use allocative::Allocative;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_traversable::Traversable;
@@ -12,7 +11,7 @@ use brk_types::{
};
use vecdb::{
AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit, LazyVecFrom1, LazyVecFrom2,
LazyVecFrom3, PAGE_SIZE, StoredIndex, VecIterator, VecIteratorExtended,
LazyVecFrom3, PAGE_SIZE, StoredIndex, VecIteratorExtended,
};
use crate::grouped::{
@@ -33,7 +32,7 @@ const TARGET_BLOCKS_PER_YEAR: u64 = 2 * TARGET_BLOCKS_PER_SEMESTER;
const TARGET_BLOCKS_PER_DECADE: u64 = 10 * TARGET_BLOCKS_PER_YEAR;
const ONE_TERA_HASH: f64 = 1_000_000_000_000.0;
#[derive(Clone, Traversable, Allocative)]
#[derive(Clone, Traversable)]
pub struct Vecs {
db: Database,
@@ -168,16 +167,14 @@ impl Vecs {
indexer.vecs.txindex_to_total_size.boxed_clone(),
|index: TxIndex, txindex_to_base_size_iter, txindex_to_total_size_iter| {
let index = index.to_usize();
txindex_to_base_size_iter
.next_at(index)
.map(|(_, base_size)| {
let total_size = txindex_to_total_size_iter.next_at(index).unwrap().1;
txindex_to_base_size_iter.get_at(index).map(|base_size| {
let total_size = txindex_to_total_size_iter.get_at_unwrap(index);
// This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
let wu = usize::from(base_size) * 3 + usize::from(total_size);
// This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
let wu = usize::from(base_size) * 3 + usize::from(total_size);
Weight::from(bitcoin::Weight::from_wu_usize(wu))
})
Weight::from(bitcoin::Weight::from_wu_usize(wu))
})
},
);
@@ -186,8 +183,7 @@ impl Vecs {
version + Version::ZERO,
txindex_to_weight.boxed_clone(),
|index: TxIndex, iter| {
let index = index.to_usize();
iter.next_at(index).map(|(_, weight)| {
iter.get(index).map(|weight| {
StoredU64::from(bitcoin::Weight::from(weight).to_vbytes_ceil() as usize)
})
},
@@ -199,15 +195,10 @@ impl Vecs {
indexer.vecs.txindex_to_height.boxed_clone(),
indexer.vecs.height_to_first_txindex.boxed_clone(),
|index: TxIndex, txindex_to_height_iter, height_to_first_txindex_iter| {
txindex_to_height_iter
.next_at(index.to_usize())
.map(|(_, height)| {
let txindex = height_to_first_txindex_iter
.next_at(height.to_usize())
.unwrap()
.1;
StoredBool::from(index == txindex)
})
txindex_to_height_iter.get(index).map(|height| {
let txindex = height_to_first_txindex_iter.get_unwrap(height);
StoredBool::from(index == txindex)
})
},
);
@@ -223,13 +214,13 @@ impl Vecs {
txinindex_to_value_iter| {
let txindex = index.to_usize();
txindex_to_first_txinindex_iter
.next_at(txindex)
.map(|(_, first_index)| {
.get_at(txindex)
.map(|first_index| {
let first_index = usize::from(first_index);
let count = *txindex_to_input_count_iter.next_at(txindex).unwrap().1;
let count = *txindex_to_input_count_iter.get_at_unwrap(txindex);
let range = first_index..first_index + count as usize;
range.into_iter().fold(Sats::ZERO, |total, txinindex| {
total + txinindex_to_value_iter.next_at(txinindex).unwrap().1
total + txinindex_to_value_iter.get_at_unwrap(txinindex)
})
})
},
@@ -261,13 +252,13 @@ impl Vecs {
txoutindex_to_value_iter| {
let txindex = index.to_usize();
txindex_to_first_txoutindex_iter
.next_at(txindex)
.map(|(_, first_index)| {
.get_at(txindex)
.map(|first_index| {
let first_index = usize::from(first_index);
let count = *txindex_to_output_count_iter.next_at(txindex).unwrap().1;
let count = *txindex_to_output_count_iter.get_at_unwrap(txindex);
let range = first_index..first_index + count as usize;
range.into_iter().fold(Sats::ZERO, |total, txoutindex| {
let v = txoutindex_to_value_iter.next_at(txoutindex).unwrap().1;
let v = txoutindex_to_value_iter.get_at_unwrap(txoutindex);
total + v
})
})
@@ -1152,7 +1143,7 @@ impl Vecs {
starting_indexes.height,
&indexes.height_to_timestamp_fixed,
|(h, t, ..)| {
while t.difference_in_days_between(height_to_timestamp_fixed_iter.unsafe_get(prev))
while t.difference_in_days_between(height_to_timestamp_fixed_iter.get_unwrap(prev))
> 0
{
prev.increment();
@@ -1209,13 +1200,13 @@ impl Vecs {
Ok(())
})?;
let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter();
let mut height_to_timestamp_iter = indexer.vecs.height_to_timestamp.iter()?;
self.height_to_interval.compute_transform(
starting_indexes.height,
&indexer.vecs.height_to_timestamp,
|(height, timestamp, ..)| {
let interval = height.decremented().map_or(Timestamp::ZERO, |prev_h| {
let prev_timestamp = height_to_timestamp_iter.unsafe_get(prev_h);
let prev_timestamp = height_to_timestamp_iter.get_unwrap(prev_h);
timestamp
.checked_sub(prev_timestamp)
.unwrap_or(Timestamp::ZERO)
@@ -1270,14 +1261,14 @@ impl Vecs {
self.difficultyepoch_to_timestamp.compute_transform(
starting_indexes.difficultyepoch,
&indexes.difficultyepoch_to_first_height,
|(i, h, ..)| (i, height_to_timestamp_iter.unsafe_get(h)),
|(i, h, ..)| (i, height_to_timestamp_iter.get_unwrap(h)),
exit,
)?;
self.halvingepoch_to_timestamp.compute_transform(
starting_indexes.halvingepoch,
&indexes.halvingepoch_to_first_height,
|(i, h, ..)| (i, height_to_timestamp_iter.unsafe_get(h)),
|(i, h, ..)| (i, height_to_timestamp_iter.get_unwrap(h)),
exit,
)?;
@@ -1292,7 +1283,7 @@ impl Vecs {
(
di,
height_to_difficultyepoch_iter
.unsafe_get(height + (*height_count_iter.unsafe_get(di) - 1)),
.get_unwrap(height + (*height_count_iter.get_unwrap(di) - 1)),
)
},
exit,
@@ -1311,7 +1302,7 @@ impl Vecs {
(
di,
height_to_halvingepoch_iter
.unsafe_get(height + (*height_count_iter.unsafe_get(di) - 1)),
.get_unwrap(height + (*height_count_iter.get_unwrap(di) - 1)),
)
},
exit,
@@ -1355,14 +1346,14 @@ impl Vecs {
let compute_indexes_to_tx_vany =
|indexes_to_tx_vany: &mut ComputedVecsFromHeight<StoredU64>, txversion| {
let mut txindex_to_txversion_iter = indexer.vecs.txindex_to_txversion.iter();
let mut txindex_to_txversion_iter = indexer.vecs.txindex_to_txversion.iter()?;
indexes_to_tx_vany.compute_all(indexes, starting_indexes, exit, |vec| {
vec.compute_filtered_count_from_indexes(
starting_indexes.height,
&indexer.vecs.height_to_first_txindex,
&indexer.vecs.txindex_to_txid,
|txindex| {
let v = txindex_to_txversion_iter.unsafe_get(txindex);
let v = txindex_to_txversion_iter.get_unwrap(txindex);
v == txversion
},
exit,
@@ -1382,7 +1373,7 @@ impl Vecs {
let value = if txoutindex == TxOutIndex::COINBASE {
Sats::MAX
} else {
txoutindex_to_value_iter.unsafe_get(txoutindex)
txoutindex_to_value_iter.get_unwrap(txoutindex)
};
(txinindex, value)
},
@@ -1392,13 +1383,13 @@ impl Vecs {
// indexes.txinindex_to_txoutindex.boxed_clone(),
// indexer.vecs.txoutindex_to_value.boxed_clone(),
// |index: TxInIndex, txinindex_to_txoutindex_iter, txoutindex_to_value_iter| {
// txinindex_to_txoutindex_iter.next_at(index.to_usize()).map(
// txinindex_to_txoutindex_iter.get_unwrap(index.to_usize()).map(
// |(txinindex, txoutindex)| {
// let txoutindex = txoutindex;
// if txoutindex == TxOutIndex::COINBASE {
// Sats::MAX
// } else if let Some((_, value)) =
// txoutindex_to_value_iter.next_at(txoutindex.to_usize())
// txoutindex_to_value_iter.get_unwrap(txoutindex.to_usize())
// {
// value
// } else {
@@ -1514,22 +1505,22 @@ impl Vecs {
self.indexes_to_coinbase
.compute_all(indexes, price, starting_indexes, exit, |vec| {
let mut txindex_to_first_txoutindex_iter =
indexer.vecs.txindex_to_first_txoutindex.iter();
indexer.vecs.txindex_to_first_txoutindex.iter()?;
let mut txindex_to_output_count_iter = indexes.txindex_to_output_count.iter();
let mut txoutindex_to_value_iter = indexer.vecs.txoutindex_to_value.iter();
let mut txoutindex_to_value_iter = indexer.vecs.txoutindex_to_value.iter()?;
vec.compute_transform(
starting_indexes.height,
&indexer.vecs.height_to_first_txindex,
|(height, txindex, ..)| {
let first_txoutindex = txindex_to_first_txoutindex_iter
.unsafe_get(txindex)
.get_unwrap(txindex)
.to_usize();
let output_count = txindex_to_output_count_iter.unsafe_get(txindex);
let output_count = txindex_to_output_count_iter.get_unwrap(txindex);
let mut sats = Sats::ZERO;
(first_txoutindex..first_txoutindex + usize::from(output_count)).for_each(
|txoutindex| {
sats += txoutindex_to_value_iter
.unsafe_get(TxOutIndex::from(txoutindex));
.get_unwrap(TxOutIndex::from(txoutindex));
},
);
(height, sats)
@@ -1553,7 +1544,7 @@ impl Vecs {
let range = *h - (*count - 1)..=*h;
let sum = range
.map(Height::from)
.map(|h| height_to_coinbase_iter.unsafe_get(h))
.map(|h| height_to_coinbase_iter.get_unwrap(h))
.sum::<Sats>();
(h, sum)
},
@@ -1572,7 +1563,7 @@ impl Vecs {
let range = *h - (*count - 1)..=*h;
let sum = range
.map(Height::from)
.map(|h| height_to_coinbase_iter.unsafe_get(h))
.map(|h| height_to_coinbase_iter.get_unwrap(h))
.sum::<Dollars>();
(h, sum)
},
@@ -1590,7 +1581,7 @@ impl Vecs {
starting_indexes.height,
self.indexes_to_coinbase.sats.height.as_ref().unwrap(),
|(height, coinbase, ..)| {
let fees = indexes_to_fee_sum_iter.unsafe_get(height);
let fees = indexes_to_fee_sum_iter.get_unwrap(height);
(height, coinbase.checked_sub(fees).unwrap())
},
exit,
@@ -1784,8 +1775,8 @@ impl Vecs {
starting_indexes.height,
self.indexes_to_output_count.height.unwrap_cumulative(),
|(h, output_count, ..)| {
let input_count = input_count_iter.unsafe_get(h);
let opreturn_count = opreturn_count_iter.unsafe_get(h);
let input_count = input_count_iter.get_unwrap(h);
let opreturn_count = opreturn_count_iter.get_unwrap(h);
let block_count = u64::from(h + 1_usize);
// -1 > genesis output is unspendable
let mut utxo_count =

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

@@ -3,7 +3,7 @@ use std::path::Path;
use brk_error::Result;
use brk_traversable::Traversable;
use brk_types::{Bitcoin, CheckedSub, Dollars, StoredF32, StoredF64, Version};
use vecdb::{Database, Exit, PAGE_SIZE, VecIterator};
use vecdb::{Database, Exit, PAGE_SIZE, VecIteratorExtended};
use crate::grouped::ComputedVecsFromDateIndex;
@@ -339,7 +339,7 @@ impl Vecs {
starting_indexes.height,
self.indexes_to_coinblocks_created.height.as_ref().unwrap(),
|(i, created, ..)| {
let destroyed = coinblocks_destroyed_iter.unsafe_get(i);
let destroyed = coinblocks_destroyed_iter.get_unwrap(i);
(i, created.checked_sub(destroyed).unwrap())
},
exit,

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

@@ -87,7 +87,7 @@ impl Vecs {
i.into(),
v,
i.decremented().map(|prev_i| {
height_to_timestamp.into_iter().get_unwrap_at(prev_i)
height_to_timestamp.into_iter().get_at_unwrap(prev_i)
}),
)
.unwrap(),
@@ -112,7 +112,7 @@ impl Vecs {
prev.replace(if i > 0 {
self.dateindex_to_price_ohlc_in_cents
.into_iter()
.get_unwrap_at(i - 1)
.get_at_unwrap(i - 1)
} else {
OHLCCents::default()
});

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

@@ -1,4 +1,3 @@
use allocative::Allocative;
use brk_error::{Error, Result};
use brk_traversable::Traversable;
use brk_types::{CheckedSub, StoredU64, Version};
@@ -11,7 +10,7 @@ use crate::utils::get_percentile;
use super::ComputedType;
#[derive(Clone, Debug, Traversable, Allocative)]
#[derive(Clone, Debug, Traversable)]
pub struct EagerVecsBuilder<I, T>
where
I: StoredIndex,
@@ -219,11 +218,11 @@ where
let cumulative_vec = self.cumulative.as_mut().unwrap();
let mut cumulative = index.decremented().map_or(T::from(0_usize), |index| {
cumulative_vec.iter().unsafe_get(index)
cumulative_vec.iter().get_unwrap(index)
});
source
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, v)| -> Result<()> {
cumulative += v;
@@ -260,17 +259,20 @@ where
let mut cumulative = cumulative_vec.map(|cumulative_vec| {
index.decremented().map_or(T::from(0_usize), |index| {
cumulative_vec.iter().unsafe_get(index)
cumulative_vec.iter().get_unwrap(index)
})
});
first_indexes.iter().skip(index).enumerate().try_for_each(
|(index, first_index)| -> Result<()> {
let count_index = count_indexes_iter.unsafe_get(index);
first_indexes
.iter()
.skip(index.to_usize())
.enumerate()
.try_for_each(|(index, first_index)| -> Result<()> {
let count_index = count_indexes_iter.get_at_unwrap(index);
if let Some(first) = self.first.as_mut() {
let f = source_iter
.get_inner(first_index)
.get(first_index)
.unwrap_or_else(|| T::from(0_usize));
first.forced_push_at(index, f, exit)?;
}
@@ -281,7 +283,7 @@ where
panic!("should compute last if count can be 0")
}
let last_index = first_index + (count_index - 1);
let v = source_iter.unsafe_get(last_index);
let v = source_iter.get_unwrap(last_index);
// .context("to work")
// .inspect_err(|_| {
// dbg!(first_index, count_index, last_index);
@@ -304,10 +306,9 @@ where
let needs_values = needs_sorted || needs_average_sum_or_cumulative;
if needs_values {
source_iter.set(first_index);
source_iter.set_position(first_index);
let mut values = (&mut source_iter)
.take(*count_index as usize)
.map(|(_, v)| v)
.collect::<Vec<_>>();
if needs_sorted {
@@ -385,8 +386,7 @@ where
}
Ok(())
},
)?;
})?;
self.safe_flush(exit)?;
@@ -431,16 +431,19 @@ where
let mut cumulative = self.cumulative.as_mut().map(|cumulative_vec| {
index.decremented().map_or(T::from(0_usize), |index| {
cumulative_vec.iter().unsafe_get(index)
cumulative_vec.iter().get_unwrap(index)
})
});
first_indexes.iter().skip(index).enumerate().try_for_each(
|(index, first_index, ..)| -> Result<()> {
let count_index = count_indexes_iter.unsafe_get(index);
first_indexes
.iter()
.skip(index.to_usize())
.enumerate()
.try_for_each(|(index, first_index, ..)| -> Result<()> {
let count_index = count_indexes_iter.get_at_unwrap(index);
if let Some(first) = self.first.as_mut() {
let v = source_first_iter.as_mut().unwrap().unsafe_get(first_index);
let v = source_first_iter.as_mut().unwrap().get_unwrap(first_index);
first.forced_push_at(index, v, exit)?;
}
@@ -450,7 +453,7 @@ where
panic!("should compute last if count can be 0")
}
let last_index = first_index + (count_index - 1);
let v = source_last_iter.as_mut().unwrap().unsafe_get(last_index);
let v = source_last_iter.as_mut().unwrap().get_unwrap(last_index);
last.forced_push_at(index, v, exit)?;
}
@@ -464,10 +467,9 @@ where
if needs_sorted {
if let Some(max) = self.max.as_mut() {
let source_max_iter = source_max_iter.as_mut().unwrap();
source_max_iter.set(first_index);
source_max_iter.set_position(first_index);
let mut values = source_max_iter
.take(*count_index as usize)
.map(|(_, v)| v)
.collect::<Vec<_>>();
values.sort_unstable();
max.forced_push_at(index, *values.last().unwrap(), exit)?;
@@ -475,10 +477,9 @@ where
if let Some(min) = self.min.as_mut() {
let source_min_iter = source_min_iter.as_mut().unwrap();
source_min_iter.set(first_index);
source_min_iter.set_position(first_index);
let mut values = source_min_iter
.take(*count_index as usize)
.map(|(_, v)| v)
.collect::<Vec<_>>();
values.sort_unstable();
min.forced_push_at(index, *values.first().unwrap(), exit)?;
@@ -488,10 +489,9 @@ where
if needs_average_sum_or_cumulative {
if let Some(average) = self.average.as_mut() {
let source_average_iter = source_average_iter.as_mut().unwrap();
source_average_iter.set(first_index);
source_average_iter.set_position(first_index);
let values = source_average_iter
.take(*count_index as usize)
.map(|(_, v)| v)
.collect::<Vec<_>>();
let len = values.len();
@@ -504,10 +504,9 @@ where
if needs_sum_or_cumulative {
let source_sum_iter = source_sum_iter.as_mut().unwrap();
source_sum_iter.set(first_index);
source_sum_iter.set_position(first_index);
let values = source_sum_iter
.take(*count_index as usize)
.map(|(_, v)| v)
.collect::<Vec<_>>();
let sum = values.into_iter().fold(T::from(0), |a, b| a + b);
@@ -526,8 +525,7 @@ where
}
Ok(())
},
)?;
})?;
self.safe_flush(exit)?;

21
crates/brk_computer/src/grouped/builder_lazy.rs
View File

@@ -1,4 +1,3 @@
use allocative::Allocative;
use brk_traversable::Traversable;
use brk_types::Version;
use vecdb::{
@@ -10,7 +9,7 @@ use crate::grouped::{EagerVecsBuilder, VecBuilderOptions};
use super::ComputedType;
#[allow(clippy::type_complexity)]
#[derive(Clone, Traversable, Allocative)]
#[derive(Clone, Traversable)]
pub struct LazyVecsBuilder<I, T, S1I, S2T>
where
I: StoredIndex,
@@ -71,7 +70,7 @@ where
if i.to_usize() >= len_source.len() {
return None;
}
source.next_at(S1I::min_from(i)).map(|(_, v)| v)
source.get_at(S1I::min_from(i))
},
))
}),
@@ -96,9 +95,7 @@ where
if i.to_usize() >= len_source.len() {
return None;
}
source
.next_at(S1I::max_from(i, source.len()))
.map(|(_, v)| v)
source.get_at(S1I::max_from(i, source.len()))
},
))
}),
@@ -116,7 +113,7 @@ where
return None;
}
S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, v)| v))
.flat_map(|i| source.get_at(i))
.min()
},
))
@@ -135,7 +132,7 @@ where
return None;
}
S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, v)| v))
.flat_map(|i| source.get_at(i))
.max()
},
))
@@ -154,7 +151,7 @@ where
return None;
}
let vec = S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, v)| v))
.flat_map(|i| source.get_at(i))
.collect::<Vec<_>>();
if vec.is_empty() {
return None;
@@ -184,7 +181,7 @@ where
return None;
}
let vec = S1I::inclusive_range_from(i, source.len())
.flat_map(|i| source.next_at(i).map(|(_, v)| v))
.flat_map(|i| source.get_at(i))
.collect::<Vec<_>>();
if vec.is_empty() {
return None;
@@ -205,9 +202,7 @@ where
if i.to_usize() >= len_source.len() {
return None;
}
source
.next_at(S1I::max_from(i, source.len()))
.map(|(_, v)| v)
source.get_at(S1I::max_from(i, source.len()))
},
))
}),

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

@@ -1,4 +1,3 @@
use allocative::Allocative;
use brk_error::Result;
use brk_traversable::Traversable;
@@ -11,7 +10,7 @@ use crate::{Indexes, grouped::LazyVecsBuilder, indexes};
use super::{ComputedType, EagerVecsBuilder, Source, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone)]
pub struct ComputedVecsFromDateIndex<T>
where
T: ComputedType + PartialOrd,

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

@@ -1,4 +1,3 @@
use allocative::Allocative;
use brk_error::Result;
use brk_traversable::Traversable;
@@ -16,7 +15,7 @@ use crate::{
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone)]
pub struct ComputedVecsFromHeight<T>
where
T: ComputedType + PartialOrd,

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

@@ -1,4 +1,3 @@
use allocative::Allocative;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_traversable::Traversable;
@@ -8,7 +7,7 @@ use brk_types::{
};
use vecdb::{
AnyCloneableIterableVec, AnyVec, CollectableVec, Database, EagerVec, Exit, GenericStoredVec,
StoredIndex, VecIterator,
StoredIndex, VecIteratorExtended,
};
use crate::{
@@ -19,7 +18,7 @@ use crate::{
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone)]
pub struct ComputedVecsFromTxindex<T>
where
T: ComputedType + PartialOrd,
@@ -253,90 +252,90 @@ impl ComputedVecsFromTxindex<Bitcoin> {
.map(Height::from)
.try_for_each(|height| -> Result<()> {
if let Some(first) = self.height.first.as_mut() {
first.forced_push_at(
first.forced_push(
height,
Bitcoin::from(sats.height.unwrap_first().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_first().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(average) = self.height.average.as_mut() {
average.forced_push_at(
average.forced_push(
height,
Bitcoin::from(sats.height.unwrap_average().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_average().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(sum) = self.height.sum.as_mut() {
sum.forced_push_at(
sum.forced_push(
height,
Bitcoin::from(sats.height.unwrap_sum().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_sum().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(max) = self.height.max.as_mut() {
max.forced_push_at(
max.forced_push(
height,
Bitcoin::from(sats.height.unwrap_max().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_max().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(pct90) = self.height.pct90.as_mut() {
pct90.forced_push_at(
pct90.forced_push(
height,
Bitcoin::from(sats.height.unwrap_pct90().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_pct90().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(pct75) = self.height.pct75.as_mut() {
pct75.forced_push_at(
pct75.forced_push(
height,
Bitcoin::from(sats.height.unwrap_pct75().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_pct75().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(median) = self.height.median.as_mut() {
median.forced_push_at(
median.forced_push(
height,
Bitcoin::from(sats.height.unwrap_median().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_median().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(pct25) = self.height.pct25.as_mut() {
pct25.forced_push_at(
pct25.forced_push(
height,
Bitcoin::from(sats.height.unwrap_pct25().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_pct25().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(pct10) = self.height.pct10.as_mut() {
pct10.forced_push_at(
pct10.forced_push(
height,
Bitcoin::from(sats.height.unwrap_pct10().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_pct10().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(min) = self.height.min.as_mut() {
min.forced_push_at(
min.forced_push(
height,
Bitcoin::from(sats.height.unwrap_min().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_min().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(last) = self.height.last.as_mut() {
last.forced_push_at(
last.forced_push(
height,
Bitcoin::from(sats.height.unwrap_last().into_iter().unsafe_get(height)),
Bitcoin::from(sats.height.unwrap_last().into_iter().get_unwrap(height)),
exit,
)?;
}
if let Some(cumulative) = self.height.cumulative.as_mut() {
cumulative.forced_push_at(
cumulative.forced_push(
height,
Bitcoin::from(
sats.height
.unwrap_cumulative()
.into_iter()
.unsafe_get(height),
.get_unwrap(height),
),
exit,
)?;
@@ -378,104 +377,104 @@ impl ComputedVecsFromTxindex<Dollars> {
(starting_index.to_usize()..indexer.vecs.height_to_weight.len())
.map(Height::from)
.try_for_each(|height| -> Result<()> {
let price = *close_iter.unsafe_get(height);
let price = *close_iter.get_unwrap(height);
if let Some(first) = self.height.first.as_mut() {
first.forced_push_at(
first.forced_push(
height,
price * bitcoin.height.unwrap_first().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_first().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(average) = self.height.average.as_mut() {
average.forced_push_at(
average.forced_push(
height,
price
* bitcoin
.height
.unwrap_average()
.into_iter()
.unsafe_get(height),
.get_unwrap(height),
exit,
)?;
}
if let Some(sum) = self.height.sum.as_mut() {
sum.forced_push_at(
sum.forced_push(
height,
price * bitcoin.height.unwrap_sum().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_sum().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(max) = self.height.max.as_mut() {
max.forced_push_at(
max.forced_push(
height,
price * bitcoin.height.unwrap_max().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_max().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(pct90) = self.height.pct90.as_mut() {
pct90.forced_push_at(
pct90.forced_push(
height,
price * bitcoin.height.unwrap_pct90().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_pct90().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(pct75) = self.height.pct75.as_mut() {
pct75.forced_push_at(
pct75.forced_push(
height,
price * bitcoin.height.unwrap_pct75().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_pct75().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(median) = self.height.median.as_mut() {
median.forced_push_at(
median.forced_push(
height,
price
* bitcoin
.height
.unwrap_median()
.into_iter()
.unsafe_get(height),
.get_unwrap(height),
exit,
)?;
}
if let Some(pct25) = self.height.pct25.as_mut() {
pct25.forced_push_at(
pct25.forced_push(
height,
price * bitcoin.height.unwrap_pct25().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_pct25().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(pct10) = self.height.pct10.as_mut() {
pct10.forced_push_at(
pct10.forced_push(
height,
price * bitcoin.height.unwrap_pct10().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_pct10().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(min) = self.height.min.as_mut() {
min.forced_push_at(
min.forced_push(
height,
price * bitcoin.height.unwrap_min().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_min().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(last) = self.height.last.as_mut() {
last.forced_push_at(
last.forced_push(
height,
price * bitcoin.height.unwrap_last().into_iter().unsafe_get(height),
price * bitcoin.height.unwrap_last().into_iter().get_unwrap(height),
exit,
)?;
}
if let Some(cumulative) = self.height.cumulative.as_mut() {
cumulative.forced_push_at(
cumulative.forced_push(
height,
price
* bitcoin
.height
.unwrap_cumulative()
.into_iter()
.unsafe_get(height),
.get_unwrap(height),
exit,
)?;
}

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

@@ -3,7 +3,7 @@ use brk_traversable::Traversable;
use brk_types::{Date, DateIndex, Dollars, StoredF32, Version};
use vecdb::{
AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
GenericStoredVec, StoredIndex, VecIterator,
GenericStoredVec, StoredIndex, VecIteratorExtended,
};
use crate::{
@@ -383,8 +383,10 @@ impl ComputedRatioVecsFromDateIndex {
.unwrap()
.min(starting_indexes.dateindex);
let min_ratio_date_usize = min_ratio_date.to_usize();
let mut sorted = self.ratio.dateindex.as_ref().unwrap().collect_range(
Some(min_ratio_date.to_usize()),
Some(min_ratio_date_usize),
Some(starting_dateindex.to_usize()),
);
@@ -395,10 +397,10 @@ impl ComputedRatioVecsFromDateIndex {
.as_ref()
.unwrap()
.iter()
.skip(starting_dateindex)
.skip(starting_dateindex.to_usize())
.enumerate()
.try_for_each(|(index, ratio)| -> Result<()> {
if index < min_ratio_date {
if index < min_ratio_date_usize {
self.ratio_pct5
.as_mut()
.unwrap()
@@ -547,7 +549,7 @@ impl ComputedRatioVecsFromDateIndex {
starting_indexes.dateindex,
date_to_price,
|(i, price, ..)| {
let multiplier = iter.unsafe_get(i);
let multiplier = iter.get_unwrap(i);
(i, price * multiplier)
},
exit,
@@ -564,7 +566,7 @@ impl ComputedRatioVecsFromDateIndex {
starting_indexes.dateindex,
date_to_price,
|(i, price, ..)| {
let multiplier = iter.unsafe_get(i);
let multiplier = iter.get_unwrap(i);
(i, price * multiplier)
},
exit,

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

@@ -1,6 +1,6 @@
use brk_error::Result;
use brk_traversable::Traversable;
use brk_types::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version};
use brk_types::{Date, DateIndex, Dollars, StoredF32, Version};
use vecdb::{
AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, Database, EagerVec,
Exit, GenericStoredVec, StoredIndex,
@@ -498,12 +498,14 @@ impl ComputedStandardDeviationVecsFromDateIndex {
let mut m2_5sd = self.m2_5sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let mut m3sd = self.m3sd.as_mut().map(|c| c.dateindex.as_mut().unwrap());
let min_date_usize = min_date.to_usize();
source
.iter()
.skip(starting_dateindex)
.skip(starting_dateindex.to_usize())
.enumerate()
.try_for_each(|(index, ratio)| -> Result<()> {
if index < min_date {
if index < min_date_usize {
self.sd.dateindex.as_mut().unwrap().forced_push_at(
index,
StoredF32::NAN,
@@ -550,9 +552,10 @@ impl ComputedStandardDeviationVecsFromDateIndex {
let pos = sorted.binary_search(&ratio).unwrap_or_else(|pos| pos);
sorted.insert(pos, ratio);
let avg = sma_iter.unsafe_get(index);
let avg = sma_iter.get_at_unwrap(index);
let population = index.checked_sub(min_date).unwrap().to_usize() as f32 + 1.0;
let population =
index.checked_sub(min_date_usize).unwrap().to_usize() as f32 + 1.0;
let sd = StoredF32::from(
(sorted.iter().map(|v| (**v - *avg).powi(2)).sum::<f32>() / population)
@@ -639,7 +642,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
starting_indexes.dateindex,
price,
|(i, price, ..)| {
let multiplier = iter.unsafe_get(i);
let multiplier = iter.get_unwrap(i);
(i, price * multiplier)
},
exit,

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

@@ -1,4 +1,3 @@
use allocative::Allocative;
use brk_error::Result;
use brk_traversable::Traversable;
use brk_types::{Bitcoin, Dollars, Height, Sats, Version};
@@ -13,7 +12,7 @@ use crate::{
use super::{ComputedVecsFromHeight, VecBuilderOptions};
#[derive(Clone, Traversable, Allocative)]
#[derive(Clone, Traversable)]
pub struct ComputedValueVecsFromHeight {
pub sats: ComputedVecsFromHeight<Sats>,
pub bitcoin: ComputedVecsFromHeight<Bitcoin>,

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

@@ -1,4 +1,3 @@
use allocative::Allocative;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_traversable::Traversable;
@@ -12,7 +11,7 @@ use crate::{Indexes, grouped::Source, indexes, price};
use super::{ComputedVecsFromTxindex, VecBuilderOptions};
#[derive(Clone, Traversable, Allocative)]
#[derive(Clone, Traversable)]
pub struct ComputedValueVecsFromTxindex {
pub sats: ComputedVecsFromTxindex<Sats>,
pub bitcoin_txindex: LazyVecFrom1<TxIndex, Bitcoin, TxIndex, Sats>,
@@ -59,8 +58,8 @@ impl ComputedValueVecsFromTxindex {
version + VERSION,
source_vec.map_or_else(|| sats.txindex.as_ref().unwrap().boxed_clone(), |s| s),
|txindex: TxIndex, iter| {
iter.next_at(txindex.to_usize())
.map(|(_, sats)| Bitcoin::from(sats))
iter.get_at(txindex.to_usize())
.map(|sats| Bitcoin::from(sats))
},
);
@@ -85,14 +84,12 @@ impl ComputedValueVecsFromTxindex {
txindex_to_height_iter,
height_to_price_close_iter| {
let txindex = txindex.to_usize();
txindex_to_btc_iter.next_at(txindex).and_then(|(_, btc)| {
txindex_to_height_iter
.next_at(txindex)
.and_then(|(_, height)| {
height_to_price_close_iter
.next_at(height.to_usize())
.map(|(_, close)| *close * btc)
})
txindex_to_btc_iter.get_at(txindex).and_then(|btc| {
txindex_to_height_iter.get_at(txindex).and_then(|height| {
height_to_price_close_iter
.get_at(height.to_usize())
.map(|close| *close * btc)
})
})
},
)

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

@@ -123,7 +123,7 @@ impl Vecs {
return TxOutIndex::COINBASE;
}
txindex_to_first_txoutindex_iter
.get_unwrap_at(outpoint.txindex().to_usize())
.get_at_unwrap(outpoint.txindex().to_usize())
+ outpoint.vout()
})
},

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

@@ -12,16 +12,16 @@ use log::info;
use vecdb::{Exit, Format};
mod blks;
// mod chain;
// mod cointime;
// mod constants;
mod chain;
mod cointime;
mod constants;
mod fetched;
// mod grouped;
mod grouped;
mod indexes;
// mod market;
// mod pools;
// mod price;
// mod stateful;
mod market;
mod pools;
mod price;
mod stateful;
mod states;
mod traits;
mod utils;
@@ -35,15 +35,15 @@ use states::*;
#[derive(Clone, Traversable)]
pub struct Computer {
pub blks: blks::Vecs,
// pub chain: chain::Vecs,
// pub cointime: cointime::Vecs,
// pub constants: constants::Vecs,
pub chain: chain::Vecs,
pub cointime: cointime::Vecs,
pub constants: constants::Vecs,
pub fetched: Option<fetched::Vecs>,
pub indexes: indexes::Vecs,
// pub market: market::Vecs,
// pub pools: pools::Vecs,
// pub price: Option<price::Vecs>,
// pub stateful: stateful::Vecs,
pub market: market::Vecs,
pub pools: pools::Vecs,
pub price: Option<price::Vecs>,
pub stateful: stateful::Vecs,
}
const VERSION: Version = Version::new(4);
@@ -81,69 +81,69 @@ impl Computer {
Ok((indexes, fetched, blks))
})?;
// let (price, constants, market) = thread::scope(|s| -> Result<_> {
// let constants_handle = big_thread().spawn_scoped(s, || {
// constants::Vecs::forced_import(&computed_path, VERSION, &indexes)
// })?;
let (price, constants, market) = thread::scope(|s| -> Result<_> {
let constants_handle = big_thread().spawn_scoped(s, || {
constants::Vecs::forced_import(&computed_path, VERSION, &indexes)
})?;
// let market_handle = big_thread().spawn_scoped(s, || {
// market::Vecs::forced_import(&computed_path, VERSION, &indexes)
// })?;
let market_handle = big_thread().spawn_scoped(s, || {
market::Vecs::forced_import(&computed_path, VERSION, &indexes)
})?;
// let price = fetched
// .is_some()
// .then(|| price::Vecs::forced_import(&computed_path, VERSION, &indexes).unwrap());
let price = fetched
.is_some()
.then(|| price::Vecs::forced_import(&computed_path, VERSION, &indexes).unwrap());
// let constants = constants_handle.join().unwrap()?;
// let market = market_handle.join().unwrap()?;
let constants = constants_handle.join().unwrap()?;
let market = market_handle.join().unwrap()?;
// Ok((price, constants, market))
// })?;
Ok((price, constants, market))
})?;
// let (chain, pools, cointime) = thread::scope(|s| -> Result<_> {
// let chain_handle = big_thread().spawn_scoped(s, || {
// chain::Vecs::forced_import(
// &computed_path,
// VERSION,
// indexer,
// &indexes,
// price.as_ref(),
// )
// })?;
let (chain, pools, cointime) = thread::scope(|s| -> Result<_> {
let chain_handle = big_thread().spawn_scoped(s, || {
chain::Vecs::forced_import(
&computed_path,
VERSION,
indexer,
&indexes,
price.as_ref(),
)
})?;
// let pools_handle = big_thread().spawn_scoped(s, || {
// pools::Vecs::forced_import(&computed_path, VERSION, &indexes, price.as_ref())
// })?;
let pools_handle = big_thread().spawn_scoped(s, || {
pools::Vecs::forced_import(&computed_path, VERSION, &indexes, price.as_ref())
})?;
// let cointime =
// cointime::Vecs::forced_import(&computed_path, VERSION, &indexes, price.as_ref())?;
let cointime =
cointime::Vecs::forced_import(&computed_path, VERSION, &indexes, price.as_ref())?;
// let chain = chain_handle.join().unwrap()?;
// let pools = pools_handle.join().unwrap()?;
let chain = chain_handle.join().unwrap()?;
let pools = pools_handle.join().unwrap()?;
// Ok((chain, pools, cointime))
// })?;
Ok((chain, pools, cointime))
})?;
// // Threads inside
// let stateful = stateful::Vecs::forced_import(
// &computed_path,
// VERSION,
// Format::Compressed,
// &indexes,
// price.as_ref(),
// )?;
// Threads inside
let stateful = stateful::Vecs::forced_import(
&computed_path,
VERSION,
Format::Compressed,
&indexes,
price.as_ref(),
)?;
Ok(Self {
// constants,
// market,
// stateful,
// chain,
constants,
market,
stateful,
chain,
blks,
// pools,
// cointime,
pools,
cointime,
indexes,
fetched,
// price,
price,
})
}
@@ -238,7 +238,7 @@ impl Computer {
}
// pub fn generate_allocation_files(monitored: &pools::Vecs) -> Result<()> {
// info!("Generating Allocative files...");
// info!("Generating allocative files...");
// let mut flamegraph = allocative::FlameGraphBuilder::default();
// flamegraph.visit_root(monitored);
@@ -265,7 +265,7 @@ impl Computer {
// std::fs::write(path.join("warnings.txt"), output.warnings())?;
// info!("Successfully generated Allocative files");
// info!("Successfully generate allocative files");
// Ok(())
// }

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

@@ -4,8 +4,7 @@ use brk_error::Result;
use brk_traversable::Traversable;
use brk_types::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredU16, Version};
use vecdb::{
Database, EagerVec, Exit, GenericStoredVec, PAGE_SIZE, StoredIndex, VecIterator,
VecIteratorExtended,
Database, EagerVec, Exit, GenericStoredVec, PAGE_SIZE, StoredIndex, VecIteratorExtended,
};
use crate::{
@@ -1594,12 +1593,12 @@ impl Vecs {
if prev.is_none() {
let i = i.to_usize();
prev.replace(if i > 0 {
slf.one_shot_get_any_or_read_(i - 1).unwrap().unwrap()
slf.get_or_read_at_once(i - 1).unwrap().unwrap()
} else {
StoredU16::default()
});
}
let days = if *high_iter.unsafe_get(i) == ath {
let days = if *high_iter.get_unwrap(i) == ath {
StoredU16::default()
} else {
prev.unwrap() + StoredU16::new(1)
@@ -1625,7 +1624,7 @@ impl Vecs {
if prev.is_none() {
let i = i.to_usize();
prev.replace(if i > 0 {
slf.one_shot_get_any_or_read_(i - 1)
slf.get_or_read_at_unwrap_once(i - 1)
} else {
StoredU16::ZERO
});

57
crates/brk_computer/src/pools/mod.rs
View File

@@ -1,6 +1,5 @@
use std::{collections::BTreeMap, path::Path};
use allocative::Allocative;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_store::AnyStore;
@@ -9,7 +8,7 @@ use brk_types::{Address, AddressBytes, Height, OutputType, PoolId, Pools, TxOutI
use rayon::prelude::*;
use vecdb::{
AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec, PAGE_SIZE, RawVec,
StoredIndex, VecIterator, Version,
StoredIndex, VecIteratorExtended, Version,
};
mod vecs;
@@ -20,7 +19,7 @@ use crate::{
price,
};
#[derive(Clone, Traversable, Allocative)]
#[derive(Clone, Traversable)]
pub struct Vecs {
db: Database,
pools: &'static Pools,
@@ -121,26 +120,28 @@ impl Vecs {
self.height_to_pool.version() + indexer.stores.height_to_coinbase_tag.version(),
)?;
let mut height_to_first_txindex_iter = indexer.vecs.height_to_first_txindex.iter();
let mut txindex_to_first_txoutindex_iter = indexer.vecs.txindex_to_first_txoutindex.iter();
let mut height_to_first_txindex_iter = indexer.vecs.height_to_first_txindex.iter()?;
let mut txindex_to_first_txoutindex_iter =
indexer.vecs.txindex_to_first_txoutindex.iter()?;
let mut txindex_to_output_count_iter = indexes.txindex_to_output_count.iter();
let mut txoutindex_to_outputtype_iter = indexer.vecs.txoutindex_to_outputtype.iter();
let mut txoutindex_to_typeindex_iter = indexer.vecs.txoutindex_to_typeindex.iter();
let mut txoutindex_to_outputtype_iter = indexer.vecs.txoutindex_to_outputtype.iter()?;
let mut txoutindex_to_typeindex_iter = indexer.vecs.txoutindex_to_typeindex.iter()?;
let mut p2pk65addressindex_to_p2pk65bytes_iter =
indexer.vecs.p2pk65addressindex_to_p2pk65bytes.iter();
indexer.vecs.p2pk65addressindex_to_p2pk65bytes.iter()?;
let mut p2pk33addressindex_to_p2pk33bytes_iter =
indexer.vecs.p2pk33addressindex_to_p2pk33bytes.iter();
indexer.vecs.p2pk33addressindex_to_p2pk33bytes.iter()?;
let mut p2pkhaddressindex_to_p2pkhbytes_iter =
indexer.vecs.p2pkhaddressindex_to_p2pkhbytes.iter();
indexer.vecs.p2pkhaddressindex_to_p2pkhbytes.iter()?;
let mut p2shaddressindex_to_p2shbytes_iter =
indexer.vecs.p2shaddressindex_to_p2shbytes.iter();
indexer.vecs.p2shaddressindex_to_p2shbytes.iter()?;
let mut p2wpkhaddressindex_to_p2wpkhbytes_iter =
indexer.vecs.p2wpkhaddressindex_to_p2wpkhbytes.iter();
indexer.vecs.p2wpkhaddressindex_to_p2wpkhbytes.iter()?;
let mut p2wshaddressindex_to_p2wshbytes_iter =
indexer.vecs.p2wshaddressindex_to_p2wshbytes.iter();
indexer.vecs.p2wshaddressindex_to_p2wshbytes.iter()?;
let mut p2traddressindex_to_p2trbytes_iter =
indexer.vecs.p2traddressindex_to_p2trbytes.iter();
let mut p2aaddressindex_to_p2abytes_iter = indexer.vecs.p2aaddressindex_to_p2abytes.iter();
indexer.vecs.p2traddressindex_to_p2trbytes.iter()?;
let mut p2aaddressindex_to_p2abytes_iter =
indexer.vecs.p2aaddressindex_to_p2abytes.iter()?;
let unknown = self.pools.get_unknown();
@@ -155,40 +156,40 @@ impl Vecs {
.iter()
.skip(min)
.try_for_each(|(height, coinbase_tag)| -> Result<()> {
let txindex = height_to_first_txindex_iter.unsafe_get(height);
let txoutindex = txindex_to_first_txoutindex_iter.unsafe_get(txindex);
let outputcount = txindex_to_output_count_iter.unsafe_get(txindex);
let txindex = height_to_first_txindex_iter.get_unwrap(height);
let txoutindex = txindex_to_first_txoutindex_iter.get_unwrap(txindex);
let outputcount = txindex_to_output_count_iter.get_unwrap(txindex);
let pool = (*txoutindex..(*txoutindex + *outputcount))
.map(TxOutIndex::from)
.find_map(|txoutindex| {
let outputtype = txoutindex_to_outputtype_iter.unsafe_get(txoutindex);
let typeindex = txoutindex_to_typeindex_iter.unsafe_get(txoutindex);
let outputtype = txoutindex_to_outputtype_iter.get_unwrap(txoutindex);
let typeindex = txoutindex_to_typeindex_iter.get_unwrap(txoutindex);
match outputtype {
OutputType::P2PK65 => Some(AddressBytes::from(
p2pk65addressindex_to_p2pk65bytes_iter.unsafe_get(typeindex.into()),
p2pk65addressindex_to_p2pk65bytes_iter.get_unwrap(typeindex.into()),
)),
OutputType::P2PK33 => Some(AddressBytes::from(
p2pk33addressindex_to_p2pk33bytes_iter.unsafe_get(typeindex.into()),
p2pk33addressindex_to_p2pk33bytes_iter.get_unwrap(typeindex.into()),
)),
OutputType::P2PKH => Some(AddressBytes::from(
p2pkhaddressindex_to_p2pkhbytes_iter.unsafe_get(typeindex.into()),
p2pkhaddressindex_to_p2pkhbytes_iter.get_unwrap(typeindex.into()),
)),
OutputType::P2SH => Some(AddressBytes::from(
p2shaddressindex_to_p2shbytes_iter.unsafe_get(typeindex.into()),
p2shaddressindex_to_p2shbytes_iter.get_unwrap(typeindex.into()),
)),
OutputType::P2WPKH => Some(AddressBytes::from(
p2wpkhaddressindex_to_p2wpkhbytes_iter.unsafe_get(typeindex.into()),
p2wpkhaddressindex_to_p2wpkhbytes_iter.get_unwrap(typeindex.into()),
)),
OutputType::P2WSH => Some(AddressBytes::from(
p2wshaddressindex_to_p2wshbytes_iter.unsafe_get(typeindex.into()),
p2wshaddressindex_to_p2wshbytes_iter.get_unwrap(typeindex.into()),
)),
OutputType::P2TR => Some(AddressBytes::from(
p2traddressindex_to_p2trbytes_iter.unsafe_get(typeindex.into()),
p2traddressindex_to_p2trbytes_iter.get_unwrap(typeindex.into()),
)),
OutputType::P2A => Some(AddressBytes::from(
p2aaddressindex_to_p2abytes_iter.unsafe_get(typeindex.into()),
p2aaddressindex_to_p2abytes_iter.get_unwrap(typeindex.into()),
)),
_ => None,
}

7
crates/brk_computer/src/pools/vecs.rs
View File

@@ -1,8 +1,7 @@
use allocative::Allocative;
use brk_error::Result;
use brk_traversable::Traversable;
use brk_types::{Height, PoolId, Pools, Sats, StoredF32, StoredU16, StoredU32};
use vecdb::{AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version};
use vecdb::{AnyIterableVec, Database, Exit, GenericStoredVec, StoredIndex, Version};
use crate::{
chain,
@@ -14,7 +13,7 @@ use crate::{
price,
};
#[derive(Clone, Traversable, Allocative)]
#[derive(Clone, Traversable)]
pub struct Vecs {
id: PoolId,
@@ -354,7 +353,7 @@ impl Vecs {
if prev.is_none() {
let i = i.to_usize();
prev.replace(if i > 0 {
slf.one_shot_get_any_or_read_(i - 1)
slf.get_or_read_at_unwrap_once(i - 1)
} else {
StoredU16::ZERO
});

142
crates/brk_computer/src/price.rs
View File

@@ -391,11 +391,8 @@ impl Vecs {
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, v)| -> Result<()> {
self.height_to_price_ohlc.forced_push_at(
Height::from(i),
OHLCDollars::from(v),
exit,
)?;
self.height_to_price_ohlc
.forced_push_at(i, OHLCDollars::from(v), exit)?;
Ok(())
})?;
self.height_to_price_ohlc.safe_flush(exit)?;
@@ -437,11 +434,8 @@ impl Vecs {
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, v)| -> Result<()> {
self.dateindex_to_price_ohlc.forced_push_at(
DateIndex::from(i),
OHLCDollars::from(v),
exit,
)?;
self.dateindex_to_price_ohlc
.forced_push_at(i, OHLCDollars::from(v), exit)?;
Ok(())
})?;
self.dateindex_to_price_ohlc.safe_flush(exit)?;
@@ -551,11 +545,11 @@ impl Vecs {
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
let open = weekindex_first_iter.unsafe_get_(i);
let high = weekindex_max_iter.unsafe_get_(i);
let low = weekindex_min_iter.unsafe_get_(i);
let open = weekindex_first_iter.get_at_unwrap(i);
let high = weekindex_max_iter.get_at_unwrap(i);
let low = weekindex_min_iter.get_at_unwrap(i);
self.weekindex_to_price_ohlc.forced_push_at(
WeekIndex::from(i),
i,
OHLCDollars {
open,
high,
@@ -590,12 +584,12 @@ impl Vecs {
.difficultyepoch
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
let open = difficultyepoch_first_iter.unsafe_get(i);
let high = difficultyepoch_max_iter.unsafe_get(i);
let low = difficultyepoch_min_iter.unsafe_get(i);
let open = difficultyepoch_first_iter.get_at_unwrap(i);
let high = difficultyepoch_max_iter.get_at_unwrap(i);
let low = difficultyepoch_min_iter.get_at_unwrap(i);
self.difficultyepoch_to_price_ohlc.forced_push_at(
i,
OHLCDollars {
@@ -628,12 +622,12 @@ impl Vecs {
.monthindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
let open = monthindex_first_iter.unsafe_get(i);
let high = monthindex_max_iter.unsafe_get(i);
let low = monthindex_min_iter.unsafe_get(i);
let open = monthindex_first_iter.get_at_unwrap(i);
let high = monthindex_max_iter.get_at_unwrap(i);
let low = monthindex_min_iter.get_at_unwrap(i);
self.monthindex_to_price_ohlc.forced_push_at(
i,
OHLCDollars {
@@ -670,12 +664,12 @@ impl Vecs {
.quarterindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
let open = quarterindex_first_iter.unsafe_get(i);
let high = quarterindex_max_iter.unsafe_get(i);
let low = quarterindex_min_iter.unsafe_get(i);
let open = quarterindex_first_iter.get_at_unwrap(i);
let high = quarterindex_max_iter.get_at_unwrap(i);
let low = quarterindex_min_iter.get_at_unwrap(i);
self.quarterindex_to_price_ohlc.forced_push_at(
i,
OHLCDollars {
@@ -712,12 +706,12 @@ impl Vecs {
.semesterindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
let open = semesterindex_first_iter.unsafe_get(i);
let high = semesterindex_max_iter.unsafe_get(i);
let low = semesterindex_min_iter.unsafe_get(i);
let open = semesterindex_first_iter.get_at_unwrap(i);
let high = semesterindex_max_iter.get_at_unwrap(i);
let low = semesterindex_min_iter.get_at_unwrap(i);
self.semesterindex_to_price_ohlc.forced_push_at(
i,
OHLCDollars {
@@ -746,12 +740,12 @@ impl Vecs {
.yearindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
let open = yearindex_first_iter.unsafe_get(i);
let high = yearindex_max_iter.unsafe_get(i);
let low = yearindex_min_iter.unsafe_get(i);
let open = yearindex_first_iter.get_at_unwrap(i);
let high = yearindex_max_iter.get_at_unwrap(i);
let low = yearindex_min_iter.get_at_unwrap(i);
self.yearindex_to_price_ohlc.forced_push_at(
i,
OHLCDollars {
@@ -791,12 +785,12 @@ impl Vecs {
.decadeindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
let open = decadeindex_first_iter.unsafe_get(i);
let high = decadeindex_max_iter.unsafe_get(i);
let low = decadeindex_min_iter.unsafe_get(i);
let open = decadeindex_first_iter.get_at_unwrap(i);
let high = decadeindex_max_iter.get_at_unwrap(i);
let low = decadeindex_min_iter.get_at_unwrap(i);
self.decadeindex_to_price_ohlc.forced_push_at(
i,
OHLCDollars {
@@ -908,15 +902,15 @@ impl Vecs {
self.chainindexes_to_price_close_in_sats
.height
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.height_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: height_first_iter.unsafe_get(i),
high: height_max_iter.unsafe_get(i),
low: height_min_iter.unsafe_get(i),
open: height_first_iter.get_at_unwrap(i),
high: height_max_iter.get_at_unwrap(i),
low: height_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -951,15 +945,15 @@ impl Vecs {
.as_ref()
.unwrap()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.dateindex_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: dateindex_first_iter.unsafe_get(i),
high: dateindex_max_iter.unsafe_get(i),
low: dateindex_min_iter.unsafe_get(i),
open: dateindex_first_iter.get_at_unwrap(i),
high: dateindex_max_iter.get_at_unwrap(i),
low: dateindex_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -990,15 +984,15 @@ impl Vecs {
.weekindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.weekindex_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: weekindex_first_iter.unsafe_get(i),
high: weekindex_max_iter.unsafe_get(i),
low: weekindex_min_iter.unsafe_get(i),
open: weekindex_first_iter.get_at_unwrap(i),
high: weekindex_max_iter.get_at_unwrap(i),
low: weekindex_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -1029,15 +1023,15 @@ impl Vecs {
.difficultyepoch
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.difficultyepoch_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: difficultyepoch_first_iter.unsafe_get(i),
high: difficultyepoch_max_iter.unsafe_get(i),
low: difficultyepoch_min_iter.unsafe_get(i),
open: difficultyepoch_first_iter.get_at_unwrap(i),
high: difficultyepoch_max_iter.get_at_unwrap(i),
low: difficultyepoch_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -1069,15 +1063,15 @@ impl Vecs {
.monthindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.monthindex_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: monthindex_first_iter.unsafe_get(i),
high: monthindex_max_iter.unsafe_get(i),
low: monthindex_min_iter.unsafe_get(i),
open: monthindex_first_iter.get_at_unwrap(i),
high: monthindex_max_iter.get_at_unwrap(i),
low: monthindex_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -1108,15 +1102,15 @@ impl Vecs {
.quarterindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.quarterindex_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: quarterindex_first_iter.unsafe_get(i),
high: quarterindex_max_iter.unsafe_get(i),
low: quarterindex_min_iter.unsafe_get(i),
open: quarterindex_first_iter.get_at_unwrap(i),
high: quarterindex_max_iter.get_at_unwrap(i),
low: quarterindex_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -1147,15 +1141,15 @@ impl Vecs {
.semesterindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.semesterindex_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: semesterindex_first_iter.unsafe_get(i),
high: semesterindex_max_iter.unsafe_get(i),
low: semesterindex_min_iter.unsafe_get(i),
open: semesterindex_first_iter.get_at_unwrap(i),
high: semesterindex_max_iter.get_at_unwrap(i),
low: semesterindex_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -1186,15 +1180,15 @@ impl Vecs {
.yearindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.yearindex_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: yearindex_first_iter.unsafe_get(i),
high: yearindex_max_iter.unsafe_get(i),
low: yearindex_min_iter.unsafe_get(i),
open: yearindex_first_iter.get_at_unwrap(i),
high: yearindex_max_iter.get_at_unwrap(i),
low: yearindex_min_iter.get_at_unwrap(i),
close,
},
exit,
@@ -1228,15 +1222,15 @@ impl Vecs {
.decadeindex
.unwrap_last()
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, close)| -> Result<()> {
self.decadeindex_to_price_ohlc_in_sats.forced_push_at(
i,
OHLCSats {
open: decadeindex_first_iter.unsafe_get(i),
high: decadeindex_max_iter.unsafe_get(i),
low: decadeindex_min_iter.unsafe_get(i),
open: decadeindex_first_iter.get_at_unwrap(i),
high: decadeindex_max_iter.get_at_unwrap(i),
low: decadeindex_min_iter.get_at_unwrap(i),
close,
},
exit,

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

@@ -5,7 +5,7 @@ use brk_traversable::Traversable;
use brk_types::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
use vecdb::{
AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, GenericStoredVec,
VecIterator,
VecIteratorExtended,
};
use crate::{
@@ -112,7 +112,7 @@ impl DynCohortVecs for Vecs {
self.state.as_mut().unwrap().addr_count = *self
.height_to_addr_count
.into_iter()
.unsafe_get(prev_height);
.get_unwrap(prev_height);
}
Ok(starting_height)
@@ -132,7 +132,7 @@ impl DynCohortVecs for Vecs {
return Ok(());
}
self.height_to_addr_count.forced_push_at(
self.height_to_addr_count.forced_push(
height,
self.state.as_ref().unwrap().addr_count.into(),
exit,

18
crates/brk_computer/src/stateful/addresstype/addresscount.rs
View File

@@ -1,7 +1,7 @@
use brk_grouper::ByAddressType;
use brk_types::Height;
use derive_deref::{Deref, DerefMut};
use vecdb::VecIterator;
use vecdb::VecIteratorExtended;
use super::AddressTypeToHeightToAddressCount;
@@ -13,14 +13,14 @@ impl From<(&AddressTypeToHeightToAddressCount, Height)> for AddressTypeToAddress
fn from((groups, starting_height): (&AddressTypeToHeightToAddressCount, Height)) -> Self {
if let Some(prev_height) = starting_height.decremented() {
Self(ByAddressType {
p2pk65: groups.p2pk65.into_iter().unsafe_get(prev_height).into(),
p2pk33: groups.p2pk33.into_iter().unsafe_get(prev_height).into(),
p2pkh: groups.p2pkh.into_iter().unsafe_get(prev_height).into(),
p2sh: groups.p2sh.into_iter().unsafe_get(prev_height).into(),
p2wpkh: groups.p2wpkh.into_iter().unsafe_get(prev_height).into(),
p2wsh: groups.p2wsh.into_iter().unsafe_get(prev_height).into(),
p2tr: groups.p2tr.into_iter().unsafe_get(prev_height).into(),
p2a: groups.p2a.into_iter().unsafe_get(prev_height).into(),
p2pk65: groups.p2pk65.into_iter().get_unwrap(prev_height).into(),
p2pk33: groups.p2pk33.into_iter().get_unwrap(prev_height).into(),
p2pkh: groups.p2pkh.into_iter().get_unwrap(prev_height).into(),
p2sh: groups.p2sh.into_iter().get_unwrap(prev_height).into(),
p2wpkh: groups.p2wpkh.into_iter().get_unwrap(prev_height).into(),
p2wsh: groups.p2wsh.into_iter().get_unwrap(prev_height).into(),
p2tr: groups.p2tr.into_iter().get_unwrap(prev_height).into(),
p2a: groups.p2a.into_iter().get_unwrap(prev_height).into(),
})
} else {
Default::default()

18
crates/brk_computer/src/stateful/addresstype/height_to_addresscount.rs
View File

@@ -18,28 +18,28 @@ impl From<ByAddressType<EagerVec<Height, StoredU64>>> for AddressTypeToHeightToA
}
impl AddressTypeToHeightToAddressCount {
pub fn forced_push_at(
pub fn forced_push(
&mut self,
height: Height,
addresstype_to_usize: &AddressTypeToAddressCount,
exit: &Exit,
) -> Result<()> {
self.p2pk65
.forced_push_at(height, addresstype_to_usize.p2pk65.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2pk65.into(), exit)?;
self.p2pk33
.forced_push_at(height, addresstype_to_usize.p2pk33.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2pk33.into(), exit)?;
self.p2pkh
.forced_push_at(height, addresstype_to_usize.p2pkh.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2pkh.into(), exit)?;
self.p2sh
.forced_push_at(height, addresstype_to_usize.p2sh.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2sh.into(), exit)?;
self.p2wpkh
.forced_push_at(height, addresstype_to_usize.p2wpkh.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2wpkh.into(), exit)?;
self.p2wsh
.forced_push_at(height, addresstype_to_usize.p2wsh.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2wsh.into(), exit)?;
self.p2tr
.forced_push_at(height, addresstype_to_usize.p2tr.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2tr.into(), exit)?;
self.p2a
.forced_push_at(height, addresstype_to_usize.p2a.into(), exit)?;
.forced_push(height, addresstype_to_usize.p2a.into(), exit)?;
Ok(())
}

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

@@ -5,7 +5,7 @@ use brk_types::{
};
use vecdb::{
AnyCloneableIterableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit,
Format, GenericStoredVec, VecIterator,
Format, GenericStoredVec, VecIteratorExtended,
};
use crate::{
@@ -1338,15 +1338,15 @@ impl Vecs {
prev_height = state.import_at_or_before(prev_height)?;
}
state.supply.value = self.height_to_supply.into_iter().unsafe_get(prev_height);
state.supply.value = self.height_to_supply.into_iter().get_unwrap(prev_height);
state.supply.utxo_count = *self
.height_to_utxo_count
.into_iter()
.unsafe_get(prev_height);
.get_unwrap(prev_height);
if let Some(height_to_realized_cap) = self.height_to_realized_cap.as_mut() {
state.realized.as_mut().unwrap().cap =
height_to_realized_cap.into_iter().unsafe_get(prev_height);
height_to_realized_cap.into_iter().get_unwrap(prev_height);
}
Ok(prev_height.incremented())
@@ -1571,22 +1571,19 @@ impl Vecs {
state: &CohortState,
) -> Result<()> {
self.height_to_supply
.forced_push_at(height, state.supply.value, exit)?;
.forced_push(height, state.supply.value, exit)?;
self.height_to_utxo_count.forced_push_at(
self.height_to_utxo_count.forced_push(
height,
StoredU64::from(state.supply.utxo_count),
exit,
)?;
self.height_to_satblocks_destroyed.forced_push_at(
height,
state.satblocks_destroyed,
exit,
)?;
self.height_to_satblocks_destroyed
.forced_push(height, state.satblocks_destroyed, exit)?;
self.height_to_satdays_destroyed
.forced_push_at(height, state.satdays_destroyed, exit)?;
.forced_push(height, state.satdays_destroyed, exit)?;
if let Some(height_to_realized_cap) = self.height_to_realized_cap.as_mut() {
let realized = state.realized.as_ref().unwrap_or_else(|| {
@@ -1594,34 +1591,36 @@ impl Vecs {
panic!();
});
height_to_realized_cap.forced_push_at(height, realized.cap, exit)?;
height_to_realized_cap.forced_push(height, realized.cap, exit)?;
self.height_to_realized_profit
.as_mut()
.unwrap()
.forced_push_at(height, realized.profit, exit)?;
self.height_to_realized_loss
.as_mut()
.unwrap()
.forced_push_at(height, realized.loss, exit)?;
self.height_to_value_created
.as_mut()
.unwrap()
.forced_push_at(height, realized.value_created, exit)?;
.forced_push(height, realized.profit, exit)?;
self.height_to_realized_loss.as_mut().unwrap().forced_push(
height,
realized.loss,
exit,
)?;
self.height_to_value_created.as_mut().unwrap().forced_push(
height,
realized.value_created,
exit,
)?;
self.height_to_value_destroyed
.as_mut()
.unwrap()
.forced_push_at(height, realized.value_destroyed, exit)?;
.forced_push(height, realized.value_destroyed, exit)?;
if self.height_to_adjusted_value_created.is_some() {
self.height_to_adjusted_value_created
.as_mut()
.unwrap()
.forced_push_at(height, realized.adj_value_created, exit)?;
.forced_push(height, realized.adj_value_created, exit)?;
self.height_to_adjusted_value_destroyed
.as_mut()
.unwrap()
.forced_push_at(height, realized.adj_value_destroyed, exit)?;
.forced_push(height, realized.adj_value_destroyed, exit)?;
}
}
Ok(())
@@ -1640,7 +1639,7 @@ impl Vecs {
self.height_to_min_price_paid
.as_mut()
.unwrap()
.forced_push_at(
.forced_push(
height,
state
.price_to_amount_first_key_value()
@@ -1651,7 +1650,7 @@ impl Vecs {
self.height_to_max_price_paid
.as_mut()
.unwrap()
.forced_push_at(
.forced_push(
height,
state
.price_to_amount_last_key_value()
@@ -1666,19 +1665,19 @@ impl Vecs {
self.height_to_supply_in_profit
.as_mut()
.unwrap()
.forced_push_at(height, height_unrealized_state.supply_in_profit, exit)?;
.forced_push(height, height_unrealized_state.supply_in_profit, exit)?;
self.height_to_supply_in_loss
.as_mut()
.unwrap()
.forced_push_at(height, height_unrealized_state.supply_in_loss, exit)?;
.forced_push(height, height_unrealized_state.supply_in_loss, exit)?;
self.height_to_unrealized_profit
.as_mut()
.unwrap()
.forced_push_at(height, height_unrealized_state.unrealized_profit, exit)?;
.forced_push(height, height_unrealized_state.unrealized_profit, exit)?;
self.height_to_unrealized_loss
.as_mut()
.unwrap()
.forced_push_at(height, height_unrealized_state.unrealized_loss, exit)?;
.forced_push(height, height_unrealized_state.unrealized_loss, exit)?;
if let Some(date_unrealized_state) = date_unrealized_state {
let dateindex = dateindex.unwrap();
@@ -1686,19 +1685,19 @@ impl Vecs {
self.dateindex_to_supply_in_profit
.as_mut()
.unwrap()
.forced_push_at(dateindex, date_unrealized_state.supply_in_profit, exit)?;
.forced_push(dateindex, date_unrealized_state.supply_in_profit, exit)?;
self.dateindex_to_supply_in_loss
.as_mut()
.unwrap()
.forced_push_at(dateindex, date_unrealized_state.supply_in_loss, exit)?;
.forced_push(dateindex, date_unrealized_state.supply_in_loss, exit)?;
self.dateindex_to_unrealized_profit
.as_mut()
.unwrap()
.forced_push_at(dateindex, date_unrealized_state.unrealized_profit, exit)?;
.forced_push(dateindex, date_unrealized_state.unrealized_profit, exit)?;
self.dateindex_to_unrealized_loss
.as_mut()
.unwrap()
.forced_push_at(dateindex, date_unrealized_state.unrealized_loss, exit)?;
.forced_push(dateindex, date_unrealized_state.unrealized_loss, exit)?;
}
}
@@ -2102,11 +2101,11 @@ impl Vecs {
starting_indexes.dateindex,
&indexes.dateindex_to_first_height,
|(i, height, ..)| {
let count = dateindex_to_height_count_iter.unsafe_get(i);
let count = dateindex_to_height_count_iter.get_unwrap(i);
if count == StoredU64::default() {
unreachable!()
}
let supply = height_to_supply_iter.unsafe_get(height + (*count - 1));
let supply = height_to_supply_iter.get_unwrap(height + (*count - 1));
(i, supply)
},
exit,

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

@@ -18,7 +18,7 @@ use smallvec::SmallVec;
use vecdb::{
AnyCloneableIterableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator,
CollectableVec, Database, EagerVec, Exit, Format, GenericStoredVec, ImportOptions,
LazyVecFrom1, PAGE_SIZE, RawVec, Reader, Stamp, StoredIndex, VecIterator,
LazyVecFrom1, PAGE_SIZE, RawVec, Reader, Stamp, StoredIndex, VecIteratorExtended,
};
use crate::{
@@ -189,7 +189,7 @@ impl Vecs {
.as_ref()
.unwrap()
.boxed_clone(),
|height: Height, iter| iter.next_at(height.to_usize()).map(|(_, d)| d),
|height: Height, iter| iter.get(height),
)
}),
indexes_to_market_cap: compute_dollars.then(|| {
@@ -712,10 +712,10 @@ impl Vecs {
.enumerate()
.map(|(height, supply)| {
let height = Height::from(height);
let timestamp = height_to_timestamp_fixed_iter.unsafe_get(height);
let timestamp = height_to_timestamp_fixed_iter.get_unwrap(height);
let price = height_to_price_close_iter
.as_mut()
.map(|i| *i.unsafe_get(height));
.map(|i| *i.get_unwrap(height));
BlockState {
timestamp,
price,
@@ -794,14 +794,14 @@ impl Vecs {
let mut unspendable_supply = if let Some(prev_height) = starting_height.decremented() {
self.height_to_unspendable_supply
.into_iter()
.unsafe_get(prev_height)
.get_unwrap(prev_height)
} else {
Sats::ZERO
};
let mut opreturn_supply = if let Some(prev_height) = starting_height.decremented() {
self.height_to_opreturn_supply
.into_iter()
.unsafe_get(prev_height)
.get_unwrap(prev_height)
} else {
Sats::ZERO
};
@@ -847,18 +847,18 @@ impl Vecs {
v.state.as_mut().unwrap().reset_single_iteration_values()
});
let timestamp = height_to_timestamp_fixed_iter.unsafe_get(height);
let timestamp = height_to_timestamp_fixed_iter.get_unwrap(height);
let price = height_to_price_close_iter
.as_mut()
.map(|i| *i.unsafe_get(height));
let first_txindex = height_to_first_txindex_iter.unsafe_get(height);
.map(|i| *i.get_unwrap(height));
let first_txindex = height_to_first_txindex_iter.get_unwrap(height);
let first_txoutindex = height_to_first_txoutindex_iter
.unsafe_get(height)
.get_unwrap(height)
.to_usize();
let first_txinindex = height_to_first_txinindex_iter.unsafe_get(height).to_usize();
let tx_count = height_to_tx_count_iter.unsafe_get(height);
let output_count = height_to_output_count_iter.unsafe_get(height);
let input_count = height_to_input_count_iter.unsafe_get(height);
let first_txinindex = height_to_first_txinindex_iter.get_unwrap(height).to_usize();
let tx_count = height_to_tx_count_iter.get_unwrap(height);
let output_count = height_to_output_count_iter.get_unwrap(height);
let input_count = height_to_input_count_iter.get_unwrap(height);
let txoutindex_to_txindex = build_txoutindex_to_txindex(
first_txindex,
@@ -874,28 +874,28 @@ impl Vecs {
let first_addressindexes: ByAddressType<TypeIndex> = ByAddressType {
p2a: height_to_first_p2aaddressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
p2pk33: height_to_first_p2pk33addressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
p2pk65: height_to_first_p2pk65addressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
p2pkh: height_to_first_p2pkhaddressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
p2sh: height_to_first_p2shaddressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
p2tr: height_to_first_p2traddressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
p2wpkh: height_to_first_p2wpkhaddressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
p2wsh: height_to_first_p2wshaddressindex_iter
.unsafe_get(height)
.get_unwrap(height)
.into(),
};
@@ -917,17 +917,17 @@ impl Vecs {
let txoutindex = TxOutIndex::from(i);
let value = txoutindex_to_value
.unwrap_read(txoutindex, &ir.txoutindex_to_value);
.read_unwrap(txoutindex, &ir.txoutindex_to_value);
let output_type = txoutindex_to_outputtype
.unwrap_read(txoutindex, &ir.txoutindex_to_outputtype);
.read_unwrap(txoutindex, &ir.txoutindex_to_outputtype);
if output_type.is_not_address() {
return (value, output_type, None);
}
let typeindex = txoutindex_to_typeindex
.unwrap_read(txoutindex, &ir.txoutindex_to_typeindex);
.read_unwrap(txoutindex, &ir.txoutindex_to_typeindex);
let addressdata_opt = Self::get_addressdatawithsource(
output_type,
@@ -996,18 +996,18 @@ impl Vecs {
let txinindex = TxInIndex::from(i);
let outpoint = txinindex_to_outpoint
.unwrap_read(txinindex, &ir.txinindex_to_outpoint);
.read_unwrap(txinindex, &ir.txinindex_to_outpoint);
let txoutindex = txindex_to_first_txoutindex.unwrap_read(
let txoutindex = txindex_to_first_txoutindex.read_unwrap(
outpoint.txindex(),
&ir.txindex_to_first_txoutindex,
) + outpoint.vout();
let value = txoutindex_to_value
.unwrap_read(txoutindex, &ir.txoutindex_to_value);
.read_unwrap(txoutindex, &ir.txoutindex_to_value);
let input_type = txoutindex_to_outputtype
.unwrap_read(txoutindex, &ir.txoutindex_to_outputtype);
.read_unwrap(txoutindex, &ir.txoutindex_to_outputtype);
let prev_height =
*txoutindex_range_to_height.get(txoutindex).unwrap();
@@ -1017,7 +1017,7 @@ impl Vecs {
}
let typeindex = txoutindex_to_typeindex
.unwrap_read(txoutindex, &ir.txoutindex_to_typeindex);
.read_unwrap(txoutindex, &ir.txoutindex_to_typeindex);
let addressdata_opt = Self::get_addressdatawithsource(
input_type,
@@ -1209,7 +1209,7 @@ impl Vecs {
.into_iter()
.map(|state| state.value)
.sum::<Sats>()
+ height_to_unclaimed_rewards_iter.unsafe_get(height);
+ height_to_unclaimed_rewards_iter.get_unwrap(height);
opreturn_supply += transacted.by_type.unspendable.opreturn.value;
@@ -1238,34 +1238,34 @@ impl Vecs {
self.utxo_cohorts.send(height_to_sent, &mut chain_state);
});
self.height_to_unspendable_supply.forced_push_at(
height,
unspendable_supply,
exit,
)?;
self.height_to_unspendable_supply
.forced_push(height, unspendable_supply, exit)?;
self.height_to_opreturn_supply
.forced_push_at(height, opreturn_supply, exit)?;
.forced_push(height, opreturn_supply, exit)?;
self.addresstype_to_height_to_addr_count.forced_push_at(
self.addresstype_to_height_to_addr_count.forced_push(
height,
&addresstype_to_addr_count,
exit,
)?;
self.addresstype_to_height_to_empty_addr_count
.forced_push_at(height, &addresstype_to_empty_addr_count, exit)?;
self.addresstype_to_height_to_empty_addr_count.forced_push(
height,
&addresstype_to_empty_addr_count,
exit,
)?;
let date = height_to_date_fixed_iter.unsafe_get(height);
let date = height_to_date_fixed_iter.get_unwrap(height);
let dateindex = DateIndex::try_from(date).unwrap();
let date_first_height = dateindex_to_first_height_iter.unsafe_get(dateindex);
let date_height_count = dateindex_to_height_count_iter.unsafe_get(dateindex);
let date_first_height = dateindex_to_first_height_iter.get_unwrap(dateindex);
let date_height_count = dateindex_to_height_count_iter.get_unwrap(dateindex);
let is_date_last_height = date_first_height
+ Height::from(date_height_count).decremented().unwrap()
== height;
let date_price = dateindex_to_price_close_iter
.as_mut()
.map(|v| is_date_last_height.then(|| *v.unsafe_get(dateindex)));
.map(|v| is_date_last_height.then(|| *v.get_unwrap(dateindex)));
let dateindex = is_date_last_height.then_some(dateindex);
@@ -1519,7 +1519,7 @@ impl Vecs {
let loadedaddressdata = addresses_data
.loaded
.get_any_or_read(loadedaddressindex, reader)
.get_or_read(loadedaddressindex, reader)
.unwrap()
.unwrap();
@@ -1533,7 +1533,7 @@ impl Vecs {
let emptyaddressdata = addresses_data
.empty
.get_any_or_read(emtpyaddressindex, reader)
.get_or_read(emtpyaddressindex, reader)
.unwrap()
.unwrap();
@@ -1979,14 +1979,14 @@ impl AnyAddressIndexes {
reader: &Reader<'static>,
) -> AnyAddressIndex {
let result = match address_type {
OutputType::P2PK33 => self.p2pk33.get_any_or_read(typeindex.into(), reader),
OutputType::P2PK65 => self.p2pk65.get_any_or_read(typeindex.into(), reader),
OutputType::P2PKH => self.p2pkh.get_any_or_read(typeindex.into(), reader),
OutputType::P2SH => self.p2sh.get_any_or_read(typeindex.into(), reader),
OutputType::P2TR => self.p2tr.get_any_or_read(typeindex.into(), reader),
OutputType::P2WPKH => self.p2wpkh.get_any_or_read(typeindex.into(), reader),
OutputType::P2WSH => self.p2wsh.get_any_or_read(typeindex.into(), reader),
OutputType::P2A => self.p2a.get_any_or_read(typeindex.into(), reader),
OutputType::P2PK33 => self.p2pk33.get_or_read(typeindex.into(), reader),
OutputType::P2PK65 => self.p2pk65.get_or_read(typeindex.into(), reader),
OutputType::P2PKH => self.p2pkh.get_or_read(typeindex.into(), reader),
OutputType::P2SH => self.p2sh.get_or_read(typeindex.into(), reader),
OutputType::P2TR => self.p2tr.get_or_read(typeindex.into(), reader),
OutputType::P2WPKH => self.p2wpkh.get_or_read(typeindex.into(), reader),
OutputType::P2WSH => self.p2wsh.get_or_read(typeindex.into(), reader),
OutputType::P2A => self.p2a.get_or_read(typeindex.into(), reader),
_ => unreachable!(),
};
result.unwrap().unwrap()
@@ -2135,7 +2135,7 @@ fn build_txoutindex_to_txindex<'a>(
let block_first_txindex = block_first_txindex.to_usize();
for tx_offset in 0..block_tx_count as usize {
let txindex = TxIndex::from(block_first_txindex + tx_offset);
let output_count = u64::from(txindex_to_output_count.unsafe_get(txindex));
let output_count = u64::from(txindex_to_output_count.get_unwrap(txindex));
for _ in 0..output_count {
vec.push(txindex);
@@ -2155,7 +2155,7 @@ fn build_txinindex_to_txindex<'a>(
let block_first_txindex = block_first_txindex.to_usize();
for tx_offset in 0..block_tx_count as usize {
let txindex = TxIndex::from(block_first_txindex + tx_offset);
let input_count = u64::from(txindex_to_input_count.unsafe_get(txindex));
let input_count = u64::from(txindex_to_input_count.get_unwrap(txindex));
for _ in 0..input_count {
vec.push(txindex);

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

@@ -29,7 +29,8 @@ where
fn from(vec: &RawVec<I, T>) -> Self {
Self(
vec.into_iter()
.map(|(i, v)| (v, i))
.enumerate()
.map(|(i, v)| (v, I::from(i)))
.collect::<BTreeMap<_, _>>(),
)
}
@@ -44,7 +45,8 @@ where
fn from(vec: &CompressedVec<I, T>) -> Self {
Self(
vec.into_iter()
.map(|(i, v)| (v, i))
.enumerate()
.map(|(i, v)| (v, I::from(i)))
.collect::<BTreeMap<_, _>>(),
)
}

32
crates/brk_computer/src/traits.rs
View File

@@ -1,8 +1,7 @@
use brk_error::Result;
use brk_types::{Bitcoin, CheckedSub, Close, Date, DateIndex, Dollars, Sats, StoredF32};
use vecdb::{
AnyIterableVec, AnyStoredVec, AnyVec, EagerVec, Exit, GenericStoredVec, StoredIndex,
VecIterator, Version,
AnyIterableVec, AnyStoredVec, AnyVec, EagerVec, Exit, GenericStoredVec, StoredIndex, Version,
};
const DCA_AMOUNT: Dollars = Dollars::mint(100.0);
@@ -51,7 +50,7 @@ impl ComputeDCAStackViaLen for EagerVec<DateIndex, Sats> {
if i_usize == 0 {
prev.replace(Sats::ZERO);
} else {
prev.replace(self.one_shot_get_any_or_read_(i_usize - 1));
prev.replace(self.read_at_unwrap_once(i_usize - 1));
}
}
@@ -61,7 +60,7 @@ impl ComputeDCAStackViaLen for EagerVec<DateIndex, Sats> {
stack = prev.unwrap() + Sats::from(Bitcoin::from(DCA_AMOUNT / price));
if i_usize >= len {
let prev_price = *other_iter.get_(i_usize - len);
let prev_price = *other_iter.get_at_unwrap(i_usize - len);
if prev_price != Dollars::ZERO {
stack = stack
.checked_sub(Sats::from(Bitcoin::from(DCA_AMOUNT / prev_price)))
@@ -92,11 +91,12 @@ impl ComputeDCAStackViaLen for EagerVec<DateIndex, Sats> {
)?;
let mut prev = None;
let from = from.to_usize();
let index = max_from.min(DateIndex::from(self.len()));
closes
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, closes)| {
let price = *closes;
@@ -105,7 +105,7 @@ impl ComputeDCAStackViaLen for EagerVec<DateIndex, Sats> {
if i_usize == 0 {
prev.replace(Sats::ZERO);
} else {
prev.replace(self.one_shot_get_any_or_read_(i_usize - 1));
prev.replace(self.read_at_unwrap_once(i_usize - 1));
}
}
@@ -157,7 +157,9 @@ impl ComputeDCAAveragePriceViaLen for EagerVec<DateIndex, Dollars> {
let index = max_from.min(DateIndex::from(self.len()));
let first_price_date = DateIndex::try_from(Date::new(2010, 7, 12)).unwrap();
let first_price_date = DateIndex::try_from(Date::new(2010, 7, 12))
.unwrap()
.to_usize();
stacks
.iter()
@@ -193,7 +195,7 @@ impl ComputeDCAAveragePriceViaLen for EagerVec<DateIndex, Dollars> {
let index = max_from.min(DateIndex::from(self.len()));
let from_usize = from.to_usize();
let from = from.to_usize();
stacks
.iter()
@@ -202,7 +204,7 @@ impl ComputeDCAAveragePriceViaLen for EagerVec<DateIndex, Dollars> {
.try_for_each(|(i, stack)| {
let mut avg_price = Dollars::from(f64::NAN);
if i >= from {
avg_price = DCA_AMOUNT * (i.to_usize() + 1 - from_usize) / Bitcoin::from(stack);
avg_price = DCA_AMOUNT * (i.to_usize() + 1 - from) / Bitcoin::from(stack);
}
self.forced_push_at(i, avg_price, exit)
})?;
@@ -237,7 +239,7 @@ where
let index = max_from.min(I::from(self.len()));
sats.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, sats)| {
let (i, v) = (i, Bitcoin::from(sats));
@@ -278,10 +280,10 @@ where
let index = max_from.min(I::from(self.len()));
bitcoin
.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, bitcoin)| {
let dollars = price_iter.unsafe_get(i);
let dollars = price_iter.get_at_unwrap(i);
let (i, v) = (i, *dollars * bitcoin);
self.forced_push_at(i, v, exit)
})?;
@@ -319,13 +321,13 @@ where
let index = max_from.min(I::from(self.len()));
let mut close_iter = close.iter();
ath.iter()
.skip(index)
.skip(index.to_usize())
.enumerate()
.try_for_each(|(i, ath)| {
if ath == Dollars::ZERO {
self.forced_push_at(i, StoredF32::default(), exit)
} else {
let close = *close_iter.unsafe_get(i);
let close = *close_iter.get_at_unwrap(i);
let drawdown = StoredF32::from((*ath - *close) / *ath * -100.0);
self.forced_push_at(i, drawdown, exit)
}