Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-07-21 16:08:10 -07:00
Code Issues Packages Projects Releases Wiki Activity

server: api doc part 4

Browse Source
This commit is contained in:
nym21
2025-10-08 18:42:36 +02:00
parent 114228e8eb
commit 83d74da556
113 changed files with 343 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_structs/src/structs/addressbytes.rs → crates/brk_structs/src/addressbytes.rs
View File
crates/brk_structs/src/structs/addressbyteshash.rs → crates/brk_structs/src/addressbyteshash.rs
View File
crates/brk_structs/src/structs/anyaddressindex.rs → crates/brk_structs/src/anyaddressindex.rs
+1 -4
View File
@@ -1,10 +1,7 @@
use serde::Serialize;
use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
use crate::{
TypeIndex,
structs::{EmptyAddressIndex, LoadedAddressIndex},
};
use crate::{EmptyAddressIndex, LoadedAddressIndex, TypeIndex};
const MIN_EMPTY_INDEX: u32 = u32::MAX - 4_000_000_000;
crates/brk_structs/src/structs/bitcoin.rs → crates/brk_structs/src/bitcoin.rs
View File
crates/brk_structs/src/structs/blkmetadata.rs → crates/brk_structs/src/blkmetadata.rs
View File
crates/brk_structs/src/structs/blkposition.rs → crates/brk_structs/src/blkposition.rs
View File
crates/brk_structs/src/structs/block.rs → crates/brk_structs/src/block.rs
View File
crates/brk_structs/src/structs/blockhash.rs → crates/brk_structs/src/blockhash.rs
View File
crates/brk_structs/src/structs/blockhashprefix.rs → crates/brk_structs/src/blockhashprefix.rs
View File
crates/brk_structs/src/structs/cents.rs → crates/brk_structs/src/cents.rs
View File
crates/brk_structs/src/structs/date.rs → crates/brk_structs/src/date.rs
View File
crates/brk_structs/src/structs/dateindex.rs → crates/brk_structs/src/dateindex.rs
View File
crates/brk_structs/src/structs/decadeindex.rs → crates/brk_structs/src/decadeindex.rs
View File
crates/brk_structs/src/structs/difficultyepoch.rs → crates/brk_structs/src/difficultyepoch.rs
View File
crates/brk_structs/src/structs/dollars.rs → crates/brk_structs/src/dollars.rs
View File
crates/brk_structs/src/structs/emptyaddressdata.rs → crates/brk_structs/src/emptyaddressdata.rs
View File
crates/brk_structs/src/structs/emptyaddressindex.rs → crates/brk_structs/src/emptyaddressindex.rs
View File
crates/brk_structs/src/structs/emptyoutputindex.rs → crates/brk_structs/src/emptyoutputindex.rs
View File
crates/brk_structs/src/structs/feerate.rs → crates/brk_structs/src/feerate.rs
View File
crates/brk_structs/src/groups/address.rs
-83
View File
@@ -1,83 +0,0 @@
use brk_traversable::Traversable;
use crate::Filtered;
use super::{ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount};
#[derive(Default, Clone)]
pub struct AddressGroups<T> {
pub ge_amount: ByGreatEqualAmount<T>,
pub amount_range: ByAmountRange<T>,
pub lt_amount: ByLowerThanAmount<T>,
}
impl<T> AddressGroups<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
self.ge_amount
.iter_mut()
.chain(self.amount_range.iter_mut())
.chain(self.lt_amount.iter_mut())
}
pub fn iter_separate_mut(&mut self) -> impl Iterator<Item = &mut T> {
self.amount_range.iter_mut()
}
pub fn iter_overlapping_mut(&mut self) -> impl Iterator<Item = &mut T> {
self.lt_amount.iter_mut().chain(self.ge_amount.iter_mut())
}
}
impl<T> AddressGroups<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
self.amount_range
.iter_right()
.chain(self.lt_amount.iter_right())
.chain(self.ge_amount.iter_right())
}
}
impl<T> From<AddressGroups<T>> for AddressGroups<Filtered<T>> {
fn from(value: AddressGroups<T>) -> Self {
Self {
amount_range: ByAmountRange::from(value.amount_range),
lt_amount: ByLowerThanAmount::from(value.lt_amount),
ge_amount: ByGreatEqualAmount::from(value.ge_amount),
}
}
}
impl<T> Traversable for AddressGroups<T>
where
ByGreatEqualAmount<T>: brk_traversable::Traversable,
ByAmountRange<T>: brk_traversable::Traversable,
ByLowerThanAmount<T>: brk_traversable::Traversable,
T: Send + Sync,
{
fn to_tree_node(&self) -> brk_traversable::TreeNode {
brk_traversable::TreeNode::Branch(
[
(String::from("ge_amount"), self.ge_amount.to_tree_node()),
(
String::from("amount_range"),
self.amount_range.to_tree_node(),
),
(String::from("lt_amount"), self.lt_amount.to_tree_node()),
]
.into(),
)
}
fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
[
Box::new(self.ge_amount.iter_any_collectable())
as Box<dyn Iterator<Item = &dyn vecdb::AnyCollectableVec>>,
Box::new(self.amount_range.iter_any_collectable())
as Box<dyn Iterator<Item = &dyn vecdb::AnyCollectableVec>>,
Box::new(self.lt_amount.iter_any_collectable())
as Box<dyn Iterator<Item = &dyn vecdb::AnyCollectableVec>>,
]
.into_iter()
.flatten()
}
}
crates/brk_structs/src/groups/by_address_type.rs
-230
View File
@@ -1,230 +0,0 @@
use std::ops::{Add, AddAssign};
use brk_traversable::{Traversable, TreeNode};
use vecdb::AnyCollectableVec;
use super::Filter;
use crate::{Filtered, OutputType};
#[derive(Default, Clone, Debug)]
pub struct ByAddressType<T> {
pub p2pk65: T,
pub p2pk33: T,
pub p2pkh: T,
pub p2sh: T,
pub p2wpkh: T,
pub p2wsh: T,
pub p2tr: T,
pub p2a: T,
}
impl<T> ByAddressType<T> {
pub fn get_unwrap(&self, address_type: OutputType) -> &T {
self.get(address_type).unwrap()
}
pub fn get(&self, address_type: OutputType) -> Option<&T> {
match address_type {
OutputType::P2PK65 => Some(&self.p2pk65),
OutputType::P2PK33 => Some(&self.p2pk33),
OutputType::P2PKH => Some(&self.p2pkh),
OutputType::P2SH => Some(&self.p2sh),
OutputType::P2WPKH => Some(&self.p2wpkh),
OutputType::P2WSH => Some(&self.p2wsh),
OutputType::P2TR => Some(&self.p2tr),
OutputType::P2A => Some(&self.p2a),
_ => None,
}
}
pub fn get_mut(&mut self, address_type: OutputType) -> Option<&mut T> {
match address_type {
OutputType::P2PK65 => Some(&mut self.p2pk65),
OutputType::P2PK33 => Some(&mut self.p2pk33),
OutputType::P2PKH => Some(&mut self.p2pkh),
OutputType::P2SH => Some(&mut self.p2sh),
OutputType::P2WPKH => Some(&mut self.p2wpkh),
OutputType::P2WSH => Some(&mut self.p2wsh),
OutputType::P2TR => Some(&mut self.p2tr),
OutputType::P2A => Some(&mut self.p2a),
_ => None,
}
}
pub fn iter(&self) -> impl Iterator<Item = &T> {
[
&self.p2pk65,
&self.p2pk33,
&self.p2pkh,
&self.p2sh,
&self.p2wpkh,
&self.p2wsh,
&self.p2tr,
&self.p2a,
]
.into_iter()
}
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self.p2pk65,
&mut self.p2pk33,
&mut self.p2pkh,
&mut self.p2sh,
&mut self.p2wpkh,
&mut self.p2wsh,
&mut self.p2tr,
&mut self.p2a,
]
.into_iter()
}
pub fn iter_typed(&self) -> impl Iterator<Item = (OutputType, &T)> {
[
(OutputType::P2PK65, &self.p2pk65),
(OutputType::P2PK33, &self.p2pk33),
(OutputType::P2PKH, &self.p2pkh),
(OutputType::P2SH, &self.p2sh),
(OutputType::P2WPKH, &self.p2wpkh),
(OutputType::P2WSH, &self.p2wsh),
(OutputType::P2TR, &self.p2tr),
(OutputType::P2A, &self.p2a),
]
.into_iter()
}
pub fn into_iter_typed(self) -> impl Iterator<Item = (OutputType, T)> {
[
(OutputType::P2PK65, self.p2pk65),
(OutputType::P2PK33, self.p2pk33),
(OutputType::P2PKH, self.p2pkh),
(OutputType::P2SH, self.p2sh),
(OutputType::P2WPKH, self.p2wpkh),
(OutputType::P2WSH, self.p2wsh),
(OutputType::P2TR, self.p2tr),
(OutputType::P2A, self.p2a),
]
.into_iter()
}
pub fn iter_typed_mut(&mut self) -> impl Iterator<Item = (OutputType, &mut T)> {
[
(OutputType::P2PK65, &mut self.p2pk65),
(OutputType::P2PK33, &mut self.p2pk33),
(OutputType::P2PKH, &mut self.p2pkh),
(OutputType::P2SH, &mut self.p2sh),
(OutputType::P2WPKH, &mut self.p2wpkh),
(OutputType::P2WSH, &mut self.p2wsh),
(OutputType::P2TR, &mut self.p2tr),
(OutputType::P2A, &mut self.p2a),
]
.into_iter()
}
}
impl<T> ByAddressType<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self.p2pk65.1,
&self.p2pk33.1,
&self.p2pkh.1,
&self.p2sh.1,
&self.p2wpkh.1,
&self.p2wsh.1,
&self.p2tr.1,
&self.p2a.1,
]
.into_iter()
}
}
impl<T> From<ByAddressType<T>> for ByAddressType<Filtered<T>> {
fn from(value: ByAddressType<T>) -> Self {
Self {
p2pk65: (Filter::Type(OutputType::P2PK65), value.p2pk65).into(),
p2pk33: (Filter::Type(OutputType::P2PK33), value.p2pk33).into(),
p2pkh: (Filter::Type(OutputType::P2PKH), value.p2pkh).into(),
p2sh: (Filter::Type(OutputType::P2SH), value.p2sh).into(),
p2wpkh: (Filter::Type(OutputType::P2WPKH), value.p2wpkh).into(),
p2wsh: (Filter::Type(OutputType::P2WSH), value.p2wsh).into(),
p2tr: (Filter::Type(OutputType::P2TR), value.p2tr).into(),
p2a: (Filter::Type(OutputType::P2A), value.p2a).into(),
}
}
}
impl<T> Add for ByAddressType<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
p2pk65: self.p2pk65 + rhs.p2pk65,
p2pk33: self.p2pk33 + rhs.p2pk33,
p2pkh: self.p2pkh + rhs.p2pkh,
p2sh: self.p2sh + rhs.p2sh,
p2wpkh: self.p2wpkh + rhs.p2wpkh,
p2wsh: self.p2wsh + rhs.p2wsh,
p2tr: self.p2tr + rhs.p2tr,
p2a: self.p2a + rhs.p2a,
}
}
}
impl<T> AddAssign for ByAddressType<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self.p2pk65 += rhs.p2pk65;
self.p2pk33 += rhs.p2pk33;
self.p2pkh += rhs.p2pkh;
self.p2sh += rhs.p2sh;
self.p2wpkh += rhs.p2wpkh;
self.p2wsh += rhs.p2wsh;
self.p2tr += rhs.p2tr;
self.p2a += rhs.p2a;
}
}
impl<T> ByAddressType<Option<T>> {
pub fn take(&mut self) {
self.iter_mut().for_each(|opt| {
opt.take();
});
}
}
impl<T: Traversable> Traversable for ByAddressType<T> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("p2pk65", &self.p2pk65),
("p2pk33", &self.p2pk33),
("p2pkh", &self.p2pkh),
("p2sh", &self.p2sh),
("p2wpkh", &self.p2wpkh),
("p2wsh", &self.p2wsh),
("p2tr", &self.p2tr),
("p2a", &self.p2a),
]
.into_iter()
.map(|(name, field)| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.p2pk65.iter_any_collectable());
iter = Box::new(iter.chain(self.p2pk33.iter_any_collectable()));
iter = Box::new(iter.chain(self.p2pkh.iter_any_collectable()));
iter = Box::new(iter.chain(self.p2sh.iter_any_collectable()));
iter = Box::new(iter.chain(self.p2wpkh.iter_any_collectable()));
iter = Box::new(iter.chain(self.p2wsh.iter_any_collectable()));
iter = Box::new(iter.chain(self.p2tr.iter_any_collectable()));
iter = Box::new(iter.chain(self.p2a.iter_any_collectable()));
iter
}
}
crates/brk_structs/src/groups/by_age_range.rs
-138
View File
@@ -1,138 +0,0 @@
use brk_traversable::Traversable;
use crate::Filtered;
use super::Filter;
#[derive(Default, Clone, Traversable)]
pub struct ByAgeRange<T> {
pub up_to_1d: T,
pub _1d_to_1w: T,
pub _1w_to_1m: T,
pub _1m_to_2m: T,
pub _2m_to_3m: T,
pub _3m_to_4m: T,
pub _4m_to_5m: T,
pub _5m_to_6m: T,
pub _6m_to_1y: T,
pub _1y_to_2y: T,
pub _2y_to_3y: T,
pub _3y_to_4y: T,
pub _4y_to_5y: T,
pub _5y_to_6y: T,
pub _6y_to_7y: T,
pub _7y_to_8y: T,
pub _8y_to_10y: T,
pub _10y_to_12y: T,
pub _12y_to_15y: T,
pub from_15y: T,
}
impl<T> From<ByAgeRange<T>> for ByAgeRange<Filtered<T>> {
fn from(value: ByAgeRange<T>) -> Self {
Self {
up_to_1d: (Filter::LowerThan(1), value.up_to_1d).into(),
_1d_to_1w: (Filter::Range(1..7), value._1d_to_1w).into(),
_1w_to_1m: (Filter::Range(7..30), value._1w_to_1m).into(),
_1m_to_2m: (Filter::Range(30..2 * 30), value._1m_to_2m).into(),
_2m_to_3m: (Filter::Range(2 * 30..3 * 30), value._2m_to_3m).into(),
_3m_to_4m: (Filter::Range(3 * 30..4 * 30), value._3m_to_4m).into(),
_4m_to_5m: (Filter::Range(4 * 30..5 * 30), value._4m_to_5m).into(),
_5m_to_6m: (Filter::Range(5 * 30..6 * 30), value._5m_to_6m).into(),
_6m_to_1y: (Filter::Range(6 * 30..365), value._6m_to_1y).into(),
_1y_to_2y: (Filter::Range(365..2 * 365), value._1y_to_2y).into(),
_2y_to_3y: (Filter::Range(2 * 365..3 * 365), value._2y_to_3y).into(),
_3y_to_4y: (Filter::Range(3 * 365..4 * 365), value._3y_to_4y).into(),
_4y_to_5y: (Filter::Range(4 * 365..5 * 365), value._4y_to_5y).into(),
_5y_to_6y: (Filter::Range(5 * 365..6 * 365), value._5y_to_6y).into(),
_6y_to_7y: (Filter::Range(6 * 365..7 * 365), value._6y_to_7y).into(),
_7y_to_8y: (Filter::Range(7 * 365..8 * 365), value._7y_to_8y).into(),
_8y_to_10y: (Filter::Range(8 * 365..10 * 365), value._8y_to_10y).into(),
_10y_to_12y: (Filter::Range(10 * 365..12 * 365), value._10y_to_12y).into(),
_12y_to_15y: (Filter::Range(12 * 365..15 * 365), value._12y_to_15y).into(),
from_15y: (Filter::GreaterOrEqual(15 * 365), value.from_15y).into(),
}
}
}
impl<T> ByAgeRange<T> {
pub fn iter(&self) -> impl Iterator<Item = &T> {
[
&self.up_to_1d,
&self._1d_to_1w,
&self._1w_to_1m,
&self._1m_to_2m,
&self._2m_to_3m,
&self._3m_to_4m,
&self._4m_to_5m,
&self._5m_to_6m,
&self._6m_to_1y,
&self._1y_to_2y,
&self._2y_to_3y,
&self._3y_to_4y,
&self._4y_to_5y,
&self._5y_to_6y,
&self._6y_to_7y,
&self._7y_to_8y,
&self._8y_to_10y,
&self._10y_to_12y,
&self._12y_to_15y,
&self.from_15y,
]
.into_iter()
}
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self.up_to_1d,
&mut self._1d_to_1w,
&mut self._1w_to_1m,
&mut self._1m_to_2m,
&mut self._2m_to_3m,
&mut self._3m_to_4m,
&mut self._4m_to_5m,
&mut self._5m_to_6m,
&mut self._6m_to_1y,
&mut self._1y_to_2y,
&mut self._2y_to_3y,
&mut self._3y_to_4y,
&mut self._4y_to_5y,
&mut self._5y_to_6y,
&mut self._6y_to_7y,
&mut self._7y_to_8y,
&mut self._8y_to_10y,
&mut self._10y_to_12y,
&mut self._12y_to_15y,
&mut self.from_15y,
]
.into_iter()
}
}
impl<T> ByAgeRange<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self.up_to_1d.1,
&self._1d_to_1w.1,
&self._1w_to_1m.1,
&self._1m_to_2m.1,
&self._2m_to_3m.1,
&self._3m_to_4m.1,
&self._4m_to_5m.1,
&self._5m_to_6m.1,
&self._6m_to_1y.1,
&self._1y_to_2y.1,
&self._2y_to_3y.1,
&self._3y_to_4y.1,
&self._4y_to_5y.1,
&self._5y_to_6y.1,
&self._6y_to_7y.1,
&self._7y_to_8y.1,
&self._8y_to_10y.1,
&self._10y_to_12y.1,
&self._12y_to_15y.1,
&self.from_15y.1,
]
.into_iter()
}
}
crates/brk_structs/src/groups/by_amount_range.rs
-277
View File
@@ -1,277 +0,0 @@
use std::ops::{Add, AddAssign};
use brk_traversable::Traversable;
use crate::{Filtered, Sats};
use super::Filter;
#[derive(Debug, Default, Clone, Traversable)]
pub struct ByAmountRange<T> {
pub _0sats: T,
pub _1sat_to_10sats: T,
pub _10sats_to_100sats: T,
pub _100sats_to_1k_sats: T,
pub _1k_sats_to_10k_sats: T,
pub _10k_sats_to_100k_sats: T,
pub _100k_sats_to_1m_sats: T,
pub _1m_sats_to_10m_sats: T,
pub _10m_sats_to_1btc: T,
pub _1btc_to_10btc: T,
pub _10btc_to_100btc: T,
pub _100btc_to_1k_btc: T,
pub _1k_btc_to_10k_btc: T,
pub _10k_btc_to_100k_btc: T,
pub _100k_btc_or_more: T,
}
impl<T> From<ByAmountRange<T>> for ByAmountRange<Filtered<T>> {
fn from(value: ByAmountRange<T>) -> Self {
#[allow(clippy::inconsistent_digit_grouping)]
Self {
_0sats: (Filter::LowerThan(Sats::_1.into()), value._0sats).into(),
_1sat_to_10sats: (
Filter::Range(Sats::_1.into()..Sats::_10.into()),
value._1sat_to_10sats,
)
.into(),
_10sats_to_100sats: (
Filter::Range(Sats::_10.into()..Sats::_100.into()),
value._10sats_to_100sats,
)
.into(),
_100sats_to_1k_sats: (
Filter::Range(Sats::_100.into()..Sats::_1K.into()),
value._100sats_to_1k_sats,
)
.into(),
_1k_sats_to_10k_sats: (
Filter::Range(Sats::_1K.into()..Sats::_10K.into()),
value._1k_sats_to_10k_sats,
)
.into(),
_10k_sats_to_100k_sats: (
Filter::Range(Sats::_10K.into()..Sats::_100K.into()),
value._10k_sats_to_100k_sats,
)
.into(),
_100k_sats_to_1m_sats: (
Filter::Range(Sats::_100K.into()..Sats::_1M.into()),
value._100k_sats_to_1m_sats,
)
.into(),
_1m_sats_to_10m_sats: (
Filter::Range(Sats::_1M.into()..Sats::_10M.into()),
value._1m_sats_to_10m_sats,
)
.into(),
_10m_sats_to_1btc: (
Filter::Range(Sats::_10M.into()..Sats::_1BTC.into()),
value._10m_sats_to_1btc,
)
.into(),
_1btc_to_10btc: (
Filter::Range(Sats::_1BTC.into()..Sats::_10BTC.into()),
value._1btc_to_10btc,
)
.into(),
_10btc_to_100btc: (
Filter::Range(Sats::_10BTC.into()..Sats::_100BTC.into()),
value._10btc_to_100btc,
)
.into(),
_100btc_to_1k_btc: (
Filter::Range(Sats::_100BTC.into()..Sats::_1K_BTC.into()),
value._100btc_to_1k_btc,
)
.into(),
_1k_btc_to_10k_btc: (
Filter::Range(Sats::_1K_BTC.into()..Sats::_10K_BTC.into()),
value._1k_btc_to_10k_btc,
)
.into(),
_10k_btc_to_100k_btc: (
Filter::Range(Sats::_10K_BTC.into()..Sats::_100K_BTC.into()),
value._10k_btc_to_100k_btc,
)
.into(),
_100k_btc_or_more: (
Filter::GreaterOrEqual(Sats::_100K_BTC.into()),
value._100k_btc_or_more,
)
.into(),
}
}
}
impl<T> ByAmountRange<T> {
#[allow(clippy::inconsistent_digit_grouping)]
pub fn get_mut(&mut self, value: Sats) -> &mut T {
if value == Sats::ZERO {
&mut self._0sats
} else if value < Sats::_10 {
&mut self._1sat_to_10sats
} else if value < Sats::_100 {
&mut self._10sats_to_100sats
} else if value < Sats::_1K {
&mut self._100sats_to_1k_sats
} else if value < Sats::_10K {
&mut self._1k_sats_to_10k_sats
} else if value < Sats::_100K {
&mut self._10k_sats_to_100k_sats
} else if value < Sats::_1M {
&mut self._100k_sats_to_1m_sats
} else if value < Sats::_10M {
&mut self._1m_sats_to_10m_sats
} else if value < Sats::_1BTC {
&mut self._10m_sats_to_1btc
} else if value < Sats::_10BTC {
&mut self._1btc_to_10btc
} else if value < Sats::_100BTC {
&mut self._10btc_to_100btc
} else if value < Sats::_1K_BTC {
&mut self._100btc_to_1k_btc
} else if value < Sats::_10K_BTC {
&mut self._1k_btc_to_10k_btc
} else if value < Sats::_100K_BTC {
&mut self._10k_btc_to_100k_btc
} else {
&mut self._100k_btc_or_more
}
}
pub fn iter(&self) -> impl Iterator<Item = &T> {
[
&self._0sats,
&self._1sat_to_10sats,
&self._10sats_to_100sats,
&self._100sats_to_1k_sats,
&self._1k_sats_to_10k_sats,
&self._10k_sats_to_100k_sats,
&self._100k_sats_to_1m_sats,
&self._1m_sats_to_10m_sats,
&self._10m_sats_to_1btc,
&self._1btc_to_10btc,
&self._10btc_to_100btc,
&self._100btc_to_1k_btc,
&self._1k_btc_to_10k_btc,
&self._10k_btc_to_100k_btc,
&self._100k_btc_or_more,
]
.into_iter()
}
pub fn iter_typed(&self) -> impl Iterator<Item = (Sats, &T)> {
[
(Sats::ZERO, &self._0sats),
(Sats::_1, &self._1sat_to_10sats),
(Sats::_10, &self._10sats_to_100sats),
(Sats::_100, &self._100sats_to_1k_sats),
(Sats::_1K, &self._1k_sats_to_10k_sats),
(Sats::_10K, &self._10k_sats_to_100k_sats),
(Sats::_100K, &self._100k_sats_to_1m_sats),
(Sats::_1M, &self._1m_sats_to_10m_sats),
(Sats::_10M, &self._10m_sats_to_1btc),
(Sats::_1BTC, &self._1btc_to_10btc),
(Sats::_10BTC, &self._10btc_to_100btc),
(Sats::_100BTC, &self._100btc_to_1k_btc),
(Sats::_1K_BTC, &self._1k_btc_to_10k_btc),
(Sats::_10K_BTC, &self._10k_btc_to_100k_btc),
(Sats::_100K_BTC, &self._100k_btc_or_more),
]
.into_iter()
}
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self._0sats,
&mut self._1sat_to_10sats,
&mut self._10sats_to_100sats,
&mut self._100sats_to_1k_sats,
&mut self._1k_sats_to_10k_sats,
&mut self._10k_sats_to_100k_sats,
&mut self._100k_sats_to_1m_sats,
&mut self._1m_sats_to_10m_sats,
&mut self._10m_sats_to_1btc,
&mut self._1btc_to_10btc,
&mut self._10btc_to_100btc,
&mut self._100btc_to_1k_btc,
&mut self._1k_btc_to_10k_btc,
&mut self._10k_btc_to_100k_btc,
&mut self._100k_btc_or_more,
]
.into_iter()
}
}
impl<T> ByAmountRange<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self._0sats.1,
&self._1sat_to_10sats.1,
&self._10sats_to_100sats.1,
&self._100sats_to_1k_sats.1,
&self._1k_sats_to_10k_sats.1,
&self._10k_sats_to_100k_sats.1,
&self._100k_sats_to_1m_sats.1,
&self._1m_sats_to_10m_sats.1,
&self._10m_sats_to_1btc.1,
&self._1btc_to_10btc.1,
&self._10btc_to_100btc.1,
&self._100btc_to_1k_btc.1,
&self._1k_btc_to_10k_btc.1,
&self._10k_btc_to_100k_btc.1,
&self._100k_btc_or_more.1,
]
.into_iter()
}
}
impl<T> Add for ByAmountRange<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
_0sats: self._0sats + rhs._0sats,
_1sat_to_10sats: self._1sat_to_10sats + rhs._1sat_to_10sats,
_10sats_to_100sats: self._10sats_to_100sats + rhs._10sats_to_100sats,
_100sats_to_1k_sats: self._100sats_to_1k_sats + rhs._100sats_to_1k_sats,
_1k_sats_to_10k_sats: self._1k_sats_to_10k_sats + rhs._1k_sats_to_10k_sats,
_10k_sats_to_100k_sats: self._10k_sats_to_100k_sats + rhs._10k_sats_to_100k_sats,
_100k_sats_to_1m_sats: self._100k_sats_to_1m_sats + rhs._100k_sats_to_1m_sats,
_1m_sats_to_10m_sats: self._1m_sats_to_10m_sats + rhs._1m_sats_to_10m_sats,
_10m_sats_to_1btc: self._10m_sats_to_1btc + rhs._10m_sats_to_1btc,
_1btc_to_10btc: self._1btc_to_10btc + rhs._1btc_to_10btc,
_10btc_to_100btc: self._10btc_to_100btc + rhs._10btc_to_100btc,
_100btc_to_1k_btc: self._100btc_to_1k_btc + rhs._100btc_to_1k_btc,
_1k_btc_to_10k_btc: self._1k_btc_to_10k_btc + rhs._1k_btc_to_10k_btc,
_10k_btc_to_100k_btc: self._10k_btc_to_100k_btc + rhs._10k_btc_to_100k_btc,
_100k_btc_or_more: self._100k_btc_or_more + rhs._100k_btc_or_more,
}
}
}
impl<T> AddAssign for ByAmountRange<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self._0sats += rhs._0sats;
self._1sat_to_10sats += rhs._1sat_to_10sats;
self._10sats_to_100sats += rhs._10sats_to_100sats;
self._100sats_to_1k_sats += rhs._100sats_to_1k_sats;
self._1k_sats_to_10k_sats += rhs._1k_sats_to_10k_sats;
self._10k_sats_to_100k_sats += rhs._10k_sats_to_100k_sats;
self._100k_sats_to_1m_sats += rhs._100k_sats_to_1m_sats;
self._1m_sats_to_10m_sats += rhs._1m_sats_to_10m_sats;
self._10m_sats_to_1btc += rhs._10m_sats_to_1btc;
self._1btc_to_10btc += rhs._1btc_to_10btc;
self._10btc_to_100btc += rhs._10btc_to_100btc;
self._100btc_to_1k_btc += rhs._100btc_to_1k_btc;
self._1k_btc_to_10k_btc += rhs._1k_btc_to_10k_btc;
self._10k_btc_to_100k_btc += rhs._10k_btc_to_100k_btc;
self._100k_btc_or_more += rhs._100k_btc_or_more;
}
}
crates/brk_structs/src/groups/by_any_address.rs
-14
View File
@@ -1,14 +0,0 @@
use brk_traversable::Traversable;
#[derive(Debug, Default, Traversable)]
pub struct ByAnyAddress<T> {
pub loaded: T,
pub empty: T,
}
impl<T> ByAnyAddress<Option<T>> {
pub fn take(&mut self) {
self.loaded.take();
self.empty.take();
}
}
crates/brk_structs/src/groups/by_epoch.rs
-62
View File
@@ -1,62 +0,0 @@
use brk_traversable::Traversable;
use crate::{Filtered, HalvingEpoch, Height};
use super::Filter;
#[derive(Default, Clone, Traversable)]
pub struct ByEpoch<T> {
pub _0: T,
pub _1: T,
pub _2: T,
pub _3: T,
pub _4: T,
}
impl<T> From<ByEpoch<T>> for ByEpoch<Filtered<T>> {
fn from(value: ByEpoch<T>) -> Self {
Self {
_0: (Filter::Epoch(HalvingEpoch::new(0)), value._0).into(),
_1: (Filter::Epoch(HalvingEpoch::new(1)), value._1).into(),
_2: (Filter::Epoch(HalvingEpoch::new(2)), value._2).into(),
_3: (Filter::Epoch(HalvingEpoch::new(3)), value._3).into(),
_4: (Filter::Epoch(HalvingEpoch::new(4)), value._4).into(),
}
}
}
impl<T> ByEpoch<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self._0,
&mut self._1,
&mut self._2,
&mut self._3,
&mut self._4,
]
.into_iter()
}
pub fn mut_vec_from_height(&mut self, height: Height) -> &mut T {
let epoch = HalvingEpoch::from(height);
if epoch == HalvingEpoch::new(0) {
&mut self._0
} else if epoch == HalvingEpoch::new(1) {
&mut self._1
} else if epoch == HalvingEpoch::new(2) {
&mut self._2
} else if epoch == HalvingEpoch::new(3) {
&mut self._3
} else if epoch == HalvingEpoch::new(4) {
&mut self._4
} else {
todo!("")
}
}
}
impl<T> ByEpoch<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1].into_iter()
}
}
crates/brk_structs/src/groups/by_ge_amount.rs
-88
View File
@@ -1,88 +0,0 @@
use brk_traversable::Traversable;
use crate::{Filtered, Sats};
use super::Filter;
#[derive(Default, Clone, Traversable)]
pub struct ByGreatEqualAmount<T> {
pub _1sat: T,
pub _10sats: T,
pub _100sats: T,
pub _1k_sats: T,
pub _10k_sats: T,
pub _100k_sats: T,
pub _1m_sats: T,
pub _10m_sats: T,
pub _1btc: T,
pub _10btc: T,
pub _100btc: T,
pub _1k_btc: T,
pub _10k_btc: T,
}
impl<T> ByGreatEqualAmount<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self._1sat,
&mut self._10sats,
&mut self._100sats,
&mut self._1k_sats,
&mut self._10k_sats,
&mut self._100k_sats,
&mut self._1m_sats,
&mut self._10m_sats,
&mut self._1btc,
&mut self._10btc,
&mut self._100btc,
&mut self._1k_btc,
&mut self._10k_btc,
]
.into_iter()
}
}
impl<T> ByGreatEqualAmount<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self._1sat.1,
&self._10sats.1,
&self._100sats.1,
&self._1k_sats.1,
&self._10k_sats.1,
&self._100k_sats.1,
&self._1m_sats.1,
&self._10m_sats.1,
&self._1btc.1,
&self._10btc.1,
&self._100btc.1,
&self._1k_btc.1,
&self._10k_btc.1,
]
.into_iter()
}
}
impl<T> From<ByGreatEqualAmount<T>> for ByGreatEqualAmount<Filtered<T>> {
fn from(value: ByGreatEqualAmount<T>) -> Self {
Self {
_1sat: (Filter::GreaterOrEqual(Sats::_1.into()), value._1sat).into(),
_10sats: (Filter::GreaterOrEqual(Sats::_10.into()), value._10sats).into(),
_100sats: (Filter::GreaterOrEqual(Sats::_100.into()), value._100sats).into(),
_1k_sats: (Filter::GreaterOrEqual(Sats::_1K.into()), value._1k_sats).into(),
_10k_sats: (Filter::GreaterOrEqual(Sats::_10K.into()), value._10k_sats).into(),
_100k_sats: (Filter::GreaterOrEqual(Sats::_100K.into()), value._100k_sats).into(),
_1m_sats: (Filter::GreaterOrEqual(Sats::_1M.into()), value._1m_sats).into(),
_10m_sats: (Filter::GreaterOrEqual(Sats::_10M.into()), value._10m_sats).into(),
_1btc: (Filter::GreaterOrEqual(Sats::_1BTC.into()), value._1btc).into(),
_10btc: (Filter::GreaterOrEqual(Sats::_10BTC.into()), value._10btc).into(),
_100btc: (Filter::GreaterOrEqual(Sats::_100BTC.into()), value._100btc).into(),
_1k_btc: (Filter::GreaterOrEqual(Sats::_1K_BTC.into()), value._1k_btc).into(),
_10k_btc: (
Filter::GreaterOrEqual(Sats::_10K_BTC.into()),
value._10k_btc,
)
.into(),
}
}
}
crates/brk_structs/src/groups/by_lt_amount.rs
-84
View File
@@ -1,84 +0,0 @@
use brk_traversable::Traversable;
use crate::{Filtered, Sats};
use super::Filter;
#[derive(Default, Clone, Traversable)]
pub struct ByLowerThanAmount<T> {
pub _10sats: T,
pub _100sats: T,
pub _1k_sats: T,
pub _10k_sats: T,
pub _100k_sats: T,
pub _1m_sats: T,
pub _10m_sats: T,
pub _1btc: T,
pub _10btc: T,
pub _100btc: T,
pub _1k_btc: T,
pub _10k_btc: T,
pub _100k_btc: T,
}
impl<T> ByLowerThanAmount<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self._10sats,
&mut self._100sats,
&mut self._1k_sats,
&mut self._10k_sats,
&mut self._100k_sats,
&mut self._1m_sats,
&mut self._10m_sats,
&mut self._1btc,
&mut self._10btc,
&mut self._100btc,
&mut self._1k_btc,
&mut self._10k_btc,
&mut self._100k_btc,
]
.into_iter()
}
}
impl<T> ByLowerThanAmount<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self._10sats.1,
&self._100sats.1,
&self._1k_sats.1,
&self._10k_sats.1,
&self._100k_sats.1,
&self._1m_sats.1,
&self._10m_sats.1,
&self._1btc.1,
&self._10btc.1,
&self._100btc.1,
&self._1k_btc.1,
&self._10k_btc.1,
&self._100k_btc.1,
]
.into_iter()
}
}
impl<T> From<ByLowerThanAmount<T>> for ByLowerThanAmount<Filtered<T>> {
fn from(value: ByLowerThanAmount<T>) -> Self {
Self {
_10sats: (Filter::LowerThan(Sats::_10.into()), value._10sats).into(),
_100sats: (Filter::LowerThan(Sats::_100.into()), value._100sats).into(),
_1k_sats: (Filter::LowerThan(Sats::_1K.into()), value._1k_sats).into(),
_10k_sats: (Filter::LowerThan(Sats::_10K.into()), value._10k_sats).into(),
_100k_sats: (Filter::LowerThan(Sats::_100K.into()), value._100k_sats).into(),
_1m_sats: (Filter::LowerThan(Sats::_1M.into()), value._1m_sats).into(),
_10m_sats: (Filter::LowerThan(Sats::_10M.into()), value._10m_sats).into(),
_1btc: (Filter::LowerThan(Sats::_1BTC.into()), value._1btc).into(),
_10btc: (Filter::LowerThan(Sats::_10BTC.into()), value._10btc).into(),
_100btc: (Filter::LowerThan(Sats::_100BTC.into()), value._100btc).into(),
_1k_btc: (Filter::LowerThan(Sats::_1K_BTC.into()), value._1k_btc).into(),
_10k_btc: (Filter::LowerThan(Sats::_10K_BTC.into()), value._10k_btc).into(),
_100k_btc: (Filter::LowerThan(Sats::_100K_BTC.into()), value._100k_btc).into(),
}
}
}
crates/brk_structs/src/groups/by_max_age.rs
-103
View File
@@ -1,103 +0,0 @@
use crate::Filtered;
use super::Filter;
use brk_traversable::Traversable;
#[derive(Default, Clone, Traversable)]
pub struct ByMaxAge<T> {
pub _1w: T,
pub _1m: T,
pub _2m: T,
pub _3m: T,
pub _4m: T,
pub _5m: T,
pub _6m: T,
pub _1y: T,
pub _2y: T,
pub _3y: T,
pub _4y: T,
pub _5y: T,
pub _6y: T,
pub _7y: T,
pub _8y: T,
pub _10y: T,
pub _12y: T,
pub _15y: T,
}
impl<T> ByMaxAge<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self._1w,
&mut self._1m,
&mut self._2m,
&mut self._3m,
&mut self._4m,
&mut self._5m,
&mut self._6m,
&mut self._1y,
&mut self._2y,
&mut self._3y,
&mut self._4y,
&mut self._5y,
&mut self._6y,
&mut self._7y,
&mut self._8y,
&mut self._10y,
&mut self._12y,
&mut self._15y,
]
.into_iter()
}
}
impl<T> ByMaxAge<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self._1w.1,
&self._1m.1,
&self._2m.1,
&self._3m.1,
&self._4m.1,
&self._5m.1,
&self._6m.1,
&self._1y.1,
&self._2y.1,
&self._3y.1,
&self._4y.1,
&self._5y.1,
&self._6y.1,
&self._7y.1,
&self._8y.1,
&self._10y.1,
&self._12y.1,
&self._15y.1,
]
.into_iter()
}
}
impl<T> From<ByMaxAge<T>> for ByMaxAge<Filtered<T>> {
fn from(value: ByMaxAge<T>) -> Self {
Self {
_1w: (Filter::LowerThan(7), value._1w).into(),
_1m: (Filter::LowerThan(30), value._1m).into(),
_2m: (Filter::LowerThan(2 * 30), value._2m).into(),
_3m: (Filter::LowerThan(3 * 30), value._3m).into(),
_4m: (Filter::LowerThan(4 * 30), value._4m).into(),
_5m: (Filter::LowerThan(5 * 30), value._5m).into(),
_6m: (Filter::LowerThan(6 * 30), value._6m).into(),
_1y: (Filter::LowerThan(365), value._1y).into(),
_2y: (Filter::LowerThan(2 * 365), value._2y).into(),
_3y: (Filter::LowerThan(3 * 365), value._3y).into(),
_4y: (Filter::LowerThan(4 * 365), value._4y).into(),
_5y: (Filter::LowerThan(5 * 365), value._5y).into(),
_6y: (Filter::LowerThan(6 * 365), value._6y).into(),
_7y: (Filter::LowerThan(7 * 365), value._7y).into(),
_8y: (Filter::LowerThan(8 * 365), value._8y).into(),
_10y: (Filter::LowerThan(10 * 365), value._10y).into(),
_12y: (Filter::LowerThan(12 * 365), value._12y).into(),
_15y: (Filter::LowerThan(15 * 365), value._15y).into(),
}
}
}
crates/brk_structs/src/groups/by_min_age.rs
-104
View File
@@ -1,104 +0,0 @@
use brk_traversable::Traversable;
use crate::Filtered;
use super::Filter;
#[derive(Default, Clone, Traversable)]
pub struct ByMinAge<T> {
pub _1d: T,
pub _1w: T,
pub _1m: T,
pub _2m: T,
pub _3m: T,
pub _4m: T,
pub _5m: T,
pub _6m: T,
pub _1y: T,
pub _2y: T,
pub _3y: T,
pub _4y: T,
pub _5y: T,
pub _6y: T,
pub _7y: T,
pub _8y: T,
pub _10y: T,
pub _12y: T,
}
impl<T> ByMinAge<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self._1d,
&mut self._1w,
&mut self._1m,
&mut self._2m,
&mut self._3m,
&mut self._4m,
&mut self._5m,
&mut self._6m,
&mut self._1y,
&mut self._2y,
&mut self._3y,
&mut self._4y,
&mut self._5y,
&mut self._6y,
&mut self._7y,
&mut self._8y,
&mut self._10y,
&mut self._12y,
]
.into_iter()
}
}
impl<T> ByMinAge<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self._1d.1,
&self._1w.1,
&self._1m.1,
&self._2m.1,
&self._3m.1,
&self._4m.1,
&self._5m.1,
&self._6m.1,
&self._1y.1,
&self._2y.1,
&self._3y.1,
&self._4y.1,
&self._5y.1,
&self._6y.1,
&self._7y.1,
&self._8y.1,
&self._10y.1,
&self._12y.1,
]
.into_iter()
}
}
impl<T> From<ByMinAge<T>> for ByMinAge<Filtered<T>> {
fn from(value: ByMinAge<T>) -> Self {
Self {
_1d: (Filter::GreaterOrEqual(1), value._1d).into(),
_1w: (Filter::GreaterOrEqual(7), value._1w).into(),
_1m: (Filter::GreaterOrEqual(30), value._1m).into(),
_2m: (Filter::GreaterOrEqual(2 * 30), value._2m).into(),
_3m: (Filter::GreaterOrEqual(3 * 30), value._3m).into(),
_4m: (Filter::GreaterOrEqual(4 * 30), value._4m).into(),
_5m: (Filter::GreaterOrEqual(5 * 30), value._5m).into(),
_6m: (Filter::GreaterOrEqual(6 * 30), value._6m).into(),
_1y: (Filter::GreaterOrEqual(365), value._1y).into(),
_2y: (Filter::GreaterOrEqual(2 * 365), value._2y).into(),
_3y: (Filter::GreaterOrEqual(3 * 365), value._3y).into(),
_4y: (Filter::GreaterOrEqual(4 * 365), value._4y).into(),
_5y: (Filter::GreaterOrEqual(5 * 365), value._5y).into(),
_6y: (Filter::GreaterOrEqual(6 * 365), value._6y).into(),
_7y: (Filter::GreaterOrEqual(7 * 365), value._7y).into(),
_8y: (Filter::GreaterOrEqual(8 * 365), value._8y).into(),
_10y: (Filter::GreaterOrEqual(10 * 365), value._10y).into(),
_12y: (Filter::GreaterOrEqual(12 * 365), value._12y).into(),
}
}
}
crates/brk_structs/src/groups/by_spendable_type.rs
-153
View File
@@ -1,153 +0,0 @@
use std::ops::{Add, AddAssign};
use brk_traversable::Traversable;
use crate::{Filtered, OutputType};
use super::Filter;
#[derive(Default, Clone, Debug, Traversable)]
pub struct BySpendableType<T> {
pub p2pk65: T,
pub p2pk33: T,
pub p2pkh: T,
pub p2ms: T,
pub p2sh: T,
pub p2wpkh: T,
pub p2wsh: T,
pub p2tr: T,
pub p2a: T,
pub unknown: T,
pub empty: T,
}
impl<T> BySpendableType<T> {
pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
match output_type {
OutputType::P2PK65 => &mut self.p2pk65,
OutputType::P2PK33 => &mut self.p2pk33,
OutputType::P2PKH => &mut self.p2pkh,
OutputType::P2MS => &mut self.p2ms,
OutputType::P2SH => &mut self.p2sh,
OutputType::P2WPKH => &mut self.p2wpkh,
OutputType::P2WSH => &mut self.p2wsh,
OutputType::P2TR => &mut self.p2tr,
OutputType::P2A => &mut self.p2a,
OutputType::Unknown => &mut self.unknown,
OutputType::Empty => &mut self.empty,
_ => unreachable!(),
}
}
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[
&mut self.p2pk65,
&mut self.p2pk33,
&mut self.p2pkh,
&mut self.p2ms,
&mut self.p2sh,
&mut self.p2wpkh,
&mut self.p2wsh,
&mut self.p2tr,
&mut self.p2a,
&mut self.unknown,
&mut self.empty,
]
.into_iter()
}
pub fn iter_typed(&self) -> impl Iterator<Item = (OutputType, &T)> {
[
(OutputType::P2PK65, &self.p2pk65),
(OutputType::P2PK33, &self.p2pk33),
(OutputType::P2PKH, &self.p2pkh),
(OutputType::P2MS, &self.p2ms),
(OutputType::P2SH, &self.p2sh),
(OutputType::P2WPKH, &self.p2wpkh),
(OutputType::P2WSH, &self.p2wsh),
(OutputType::P2TR, &self.p2tr),
(OutputType::P2A, &self.p2a),
(OutputType::Unknown, &self.unknown),
(OutputType::Empty, &self.empty),
]
.into_iter()
}
}
impl<T> BySpendableType<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[
&self.p2pk65.1,
&self.p2pk33.1,
&self.p2pkh.1,
&self.p2ms.1,
&self.p2sh.1,
&self.p2wpkh.1,
&self.p2wsh.1,
&self.p2tr.1,
&self.p2a.1,
&self.unknown.1,
&self.empty.1,
]
.into_iter()
}
}
impl<T> From<BySpendableType<T>> for BySpendableType<Filtered<T>> {
fn from(value: BySpendableType<T>) -> Self {
Self {
p2pk65: (Filter::Type(OutputType::P2PK65), value.p2pk65).into(),
p2pk33: (Filter::Type(OutputType::P2PK33), value.p2pk33).into(),
p2pkh: (Filter::Type(OutputType::P2PKH), value.p2pkh).into(),
p2ms: (Filter::Type(OutputType::P2MS), value.p2ms).into(),
p2sh: (Filter::Type(OutputType::P2SH), value.p2sh).into(),
p2wpkh: (Filter::Type(OutputType::P2WPKH), value.p2wpkh).into(),
p2wsh: (Filter::Type(OutputType::P2WSH), value.p2wsh).into(),
p2tr: (Filter::Type(OutputType::P2TR), value.p2tr).into(),
p2a: (Filter::Type(OutputType::P2A), value.p2a).into(),
unknown: (Filter::Type(OutputType::Unknown), value.unknown).into(),
empty: (Filter::Type(OutputType::Empty), value.empty).into(),
}
}
}
impl<T> Add for BySpendableType<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
p2pk65: self.p2pk65 + rhs.p2pk65,
p2pk33: self.p2pk33 + rhs.p2pk33,
p2pkh: self.p2pkh + rhs.p2pkh,
p2ms: self.p2ms + rhs.p2ms,
p2sh: self.p2sh + rhs.p2sh,
p2wpkh: self.p2wpkh + rhs.p2wpkh,
p2wsh: self.p2wsh + rhs.p2wsh,
p2tr: self.p2tr + rhs.p2tr,
p2a: self.p2a + rhs.p2a,
unknown: self.unknown + rhs.unknown,
empty: self.empty + rhs.empty,
}
}
}
impl<T> AddAssign for BySpendableType<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self.p2pk65 += rhs.p2pk65;
self.p2pk33 += rhs.p2pk33;
self.p2pkh += rhs.p2pkh;
self.p2ms += rhs.p2ms;
self.p2sh += rhs.p2sh;
self.p2wpkh += rhs.p2wpkh;
self.p2wsh += rhs.p2wsh;
self.p2tr += rhs.p2tr;
self.p2a += rhs.p2a;
self.unknown += rhs.unknown;
self.empty += rhs.empty;
}
}
crates/brk_structs/src/groups/by_term.rs
-32
View File
@@ -1,32 +0,0 @@
use brk_traversable::Traversable;
use crate::Filtered;
use super::Filter;
#[derive(Default, Clone, Traversable)]
pub struct ByTerm<T> {
pub short: T,
pub long: T,
}
impl<T> ByTerm<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[&mut self.short, &mut self.long].into_iter()
}
}
impl<T> ByTerm<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[&self.short.1, &self.long.1].into_iter()
}
}
impl<T> From<ByTerm<T>> for ByTerm<Filtered<T>> {
fn from(value: ByTerm<T>) -> Self {
Self {
short: (Filter::LowerThan(5 * 30), value.short).into(),
long: (Filter::GreaterOrEqual(5 * 30), value.long).into(),
}
}
}
crates/brk_structs/src/groups/by_type.rs
-72
View File
@@ -1,72 +0,0 @@
use std::ops::{Add, AddAssign};
use crate::OutputType;
use super::{BySpendableType, ByUnspendableType};
#[derive(Default, Clone, Debug)]
pub struct GroupedByType<T> {
pub spendable: BySpendableType<T>,
pub unspendable: ByUnspendableType<T>,
}
impl<T> GroupedByType<T> {
pub fn get(&self, output_type: OutputType) -> &T {
match output_type {
OutputType::P2PK65 => &self.spendable.p2pk65,
OutputType::P2PK33 => &self.spendable.p2pk33,
OutputType::P2PKH => &self.spendable.p2pkh,
OutputType::P2MS => &self.spendable.p2ms,
OutputType::P2SH => &self.spendable.p2sh,
OutputType::P2WPKH => &self.spendable.p2wpkh,
OutputType::P2WSH => &self.spendable.p2wsh,
OutputType::P2TR => &self.spendable.p2tr,
OutputType::P2A => &self.spendable.p2a,
OutputType::Empty => &self.spendable.empty,
OutputType::Unknown => &self.spendable.unknown,
OutputType::OpReturn => &self.unspendable.opreturn,
_ => unreachable!(),
}
}
pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
match output_type {
OutputType::P2PK65 => &mut self.spendable.p2pk65,
OutputType::P2PK33 => &mut self.spendable.p2pk33,
OutputType::P2PKH => &mut self.spendable.p2pkh,
OutputType::P2MS => &mut self.spendable.p2ms,
OutputType::P2SH => &mut self.spendable.p2sh,
OutputType::P2WPKH => &mut self.spendable.p2wpkh,
OutputType::P2WSH => &mut self.spendable.p2wsh,
OutputType::P2TR => &mut self.spendable.p2tr,
OutputType::P2A => &mut self.spendable.p2a,
OutputType::Unknown => &mut self.spendable.unknown,
OutputType::Empty => &mut self.spendable.empty,
OutputType::OpReturn => &mut self.unspendable.opreturn,
_ => unreachable!(),
}
}
}
impl<T> Add for GroupedByType<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
spendable: self.spendable + rhs.spendable,
unspendable: self.unspendable + rhs.unspendable,
}
}
}
impl<T> AddAssign for GroupedByType<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self.spendable += rhs.spendable;
self.unspendable += rhs.unspendable;
}
}
crates/brk_structs/src/groups/by_unspendable_type.rs
-35
View File
@@ -1,35 +0,0 @@
use std::ops::{Add, AddAssign};
use brk_traversable::Traversable;
#[derive(Default, Clone, Debug, Traversable)]
pub struct ByUnspendableType<T> {
pub opreturn: T,
}
impl<T> ByUnspendableType<T> {
pub fn as_vec(&self) -> [&T; 1] {
[&self.opreturn]
}
}
impl<T> Add for ByUnspendableType<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
opreturn: self.opreturn + rhs.opreturn,
}
}
}
impl<T> AddAssign for ByUnspendableType<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self.opreturn += rhs.opreturn;
}
}
crates/brk_structs/src/groups/by_value.rs
-37
View File
@@ -1,37 +0,0 @@
#[derive(Default, Clone)]
pub struct GroupedByValue<T> {
pub up_to_1cent: T,
pub from_1c_to_10c: T,
pub from_10c_to_1d: T,
pub from_1d_to_10d: T,
pub from_10usd_to_100usd: T,
pub from_100usd_to_1_000usd: T,
pub from_1_000usd_to_10_000usd: T,
pub from_10_000usd_to_100_000usd: T,
pub from_100_000usd_to_1_000_000usd: T,
pub from_1_000_000usd_to_10_000_000usd: T,
pub from_10_000_000usd_to_100_000_000usd: T,
pub from_100_000_000usd_to_1_000_000_000usd: T,
pub from_1_000_000_000usd: T,
// ...
}
impl<T> GroupedByValue<T> {
pub fn as_mut_vec(&mut self) -> Vec<&mut T> {
vec![
&mut self.up_to_1cent,
&mut self.from_1c_to_10c,
&mut self.from_10c_to_1d,
&mut self.from_1d_to_10d,
&mut self.from_10usd_to_100usd,
&mut self.from_100usd_to_1_000usd,
&mut self.from_1_000usd_to_10_000usd,
&mut self.from_10_000usd_to_100_000usd,
&mut self.from_100_000usd_to_1_000_000usd,
&mut self.from_1_000_000usd_to_10_000_000usd,
&mut self.from_10_000_000usd_to_100_000_000usd,
&mut self.from_100_000_000usd_to_1_000_000_000usd,
&mut self.from_1_000_000_000usd,
]
}
}
crates/brk_structs/src/groups/filter.rs
-88
View File
@@ -1,88 +0,0 @@
use std::ops::Range;
use brk_traversable::{Traversable, TreeNode};
use vecdb::AnyCollectableVec;
use crate::{HalvingEpoch, OutputType};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Filter {
All,
LowerThan(usize),
Range(Range<usize>),
GreaterOrEqual(usize),
Epoch(HalvingEpoch),
Type(OutputType),
}
impl Filter {
pub fn contains(&self, value: usize) -> bool {
match self {
Filter::Range(r) => r.contains(&value),
Filter::LowerThan(max) => *max > value,
Filter::GreaterOrEqual(min) => *min <= value,
Filter::All => true,
Filter::Epoch(_) | Filter::Type(_) => false,
}
}
pub fn includes(&self, other: &Filter) -> bool {
match self {
Filter::All => true,
Filter::LowerThan(max) => match other {
Filter::LowerThan(max2) => max >= max2,
Filter::Range(range) => range.end <= *max,
Filter::All | Filter::GreaterOrEqual(_) | Filter::Epoch(_) | Filter::Type(_) => {
false
}
},
Filter::GreaterOrEqual(min) => match other {
Filter::Range(range) => range.start >= *min,
Filter::GreaterOrEqual(min2) => min <= min2,
Filter::All | Filter::LowerThan(_) | Filter::Epoch(_) | Filter::Type(_) => false,
},
Filter::Range(_) | Filter::Epoch(_) | Filter::Type(_) => false,
}
}
}
#[derive(Clone)]
pub struct Filtered<T>(pub Filter, pub T);
impl<T> Filtered<T> {
pub fn includes(&self, other: &Filter) -> bool {
self.0.includes(other)
}
pub fn filter(&self) -> &Filter {
&self.0
}
pub fn unwrap(self) -> T {
self.1
}
pub fn t(&self) -> &T {
&self.1
}
pub fn mut_t(&mut self) -> &mut T {
&mut self.1
}
}
impl<T> From<(Filter, T)> for Filtered<T> {
fn from(value: (Filter, T)) -> Self {
Self(value.0, value.1)
}
}
impl<T: Traversable> Traversable for Filtered<T> {
fn to_tree_node(&self) -> TreeNode {
self.1.to_tree_node()
}
fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.1.iter_any_collectable()
}
}
crates/brk_structs/src/groups/mod.rs
-33
View File
@@ -1,33 +0,0 @@
mod address;
mod by_address_type;
mod by_age_range;
mod by_amount_range;
mod by_any_address;
mod by_epoch;
mod by_ge_amount;
mod by_lt_amount;
mod by_max_age;
mod by_min_age;
mod by_spendable_type;
mod by_term;
mod by_type;
mod by_unspendable_type;
mod filter;
mod utxo;
pub use address::*;
pub use by_address_type::*;
pub use by_age_range::*;
pub use by_amount_range::*;
pub use by_any_address::*;
pub use by_epoch::*;
pub use by_ge_amount::*;
pub use by_lt_amount::*;
pub use by_max_age::*;
pub use by_min_age::*;
pub use by_spendable_type::*;
pub use by_term::*;
pub use by_type::*;
pub use by_unspendable_type::*;
pub use filter::*;
pub use utxo::*;
crates/brk_structs/src/groups/utxo.rs
-87
View File
@@ -1,87 +0,0 @@
use brk_traversable::Traversable;
use crate::{
ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge, ByMinAge,
BySpendableType, ByTerm, Filter, Filtered,
};
#[derive(Default, Clone, Traversable)]
pub struct UTXOGroups<T> {
pub all: T,
pub age_range: ByAgeRange<T>,
pub epoch: ByEpoch<T>,
pub min_age: ByMinAge<T>,
pub ge_amount: ByGreatEqualAmount<T>,
pub amount_range: ByAmountRange<T>,
pub term: ByTerm<T>,
pub _type: BySpendableType<T>,
pub max_age: ByMaxAge<T>,
pub lt_amount: ByLowerThanAmount<T>,
}
impl<T> UTXOGroups<T> {
pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
[&mut self.all]
.into_iter()
.chain(self.term.iter_mut())
.chain(self.max_age.iter_mut())
.chain(self.min_age.iter_mut())
.chain(self.ge_amount.iter_mut())
.chain(self.age_range.iter_mut())
.chain(self.epoch.iter_mut())
.chain(self.amount_range.iter_mut())
.chain(self.lt_amount.iter_mut())
.chain(self._type.iter_mut())
}
pub fn iter_separate_mut(&mut self) -> impl Iterator<Item = &mut T> {
self.age_range
.iter_mut()
.chain(self.epoch.iter_mut())
.chain(self.amount_range.iter_mut())
.chain(self._type.iter_mut())
}
pub fn iter_overlapping_mut(&mut self) -> impl Iterator<Item = &mut T> {
[&mut self.all]
.into_iter()
.chain(self.term.iter_mut())
.chain(self.max_age.iter_mut())
.chain(self.min_age.iter_mut())
.chain(self.lt_amount.iter_mut())
.chain(self.ge_amount.iter_mut())
}
}
impl<T> UTXOGroups<Filtered<T>> {
pub fn iter_right(&self) -> impl Iterator<Item = &T> {
[&self.all.1]
.into_iter()
.chain(self.term.iter_right())
.chain(self.max_age.iter_right())
.chain(self.min_age.iter_right())
.chain(self.age_range.iter_right())
.chain(self.epoch.iter_right())
.chain(self.amount_range.iter_right())
.chain(self._type.iter_right())
.chain(self.lt_amount.iter_right())
.chain(self.ge_amount.iter_right())
}
}
impl<T> From<UTXOGroups<T>> for UTXOGroups<Filtered<T>> {
fn from(value: UTXOGroups<T>) -> Self {
Self {
all: (Filter::All, value.all).into(),
term: ByTerm::from(value.term),
max_age: ByMaxAge::from(value.max_age),
min_age: ByMinAge::from(value.min_age),
age_range: ByAgeRange::from(value.age_range),
epoch: ByEpoch::from(value.epoch),
amount_range: ByAmountRange::from(value.amount_range),
lt_amount: ByLowerThanAmount::from(value.lt_amount),
ge_amount: ByGreatEqualAmount::from(value.ge_amount),
_type: BySpendableType::from(value._type),
}
}
}
crates/brk_structs/src/structs/halvingepoch.rs → crates/brk_structs/src/halvingepoch.rs
View File
crates/brk_structs/src/structs/height.rs → crates/brk_structs/src/height.rs
View File
crates/brk_structs/src/structs/index.rs → crates/brk_structs/src/index.rs
View File
crates/brk_structs/src/structs/indexinfo.rs → crates/brk_structs/src/indexinfo.rs
View File
crates/brk_structs/src/structs/inputindex.rs → crates/brk_structs/src/inputindex.rs
View File
crates/brk_structs/src/lib.rs
+172 -6
View File
@@ -1,9 +1,175 @@
#![doc = include_str!("../README.md")]
mod groups;
mod structs;
pub use groups::*;
pub use structs::*;
pub use vecdb::{CheckedSub, Exit, PrintableIndex, Version};
use brk_error::{Error, Result};
mod addressbytes;
mod addressbyteshash;
mod anyaddressindex;
mod bitcoin;
mod blkmetadata;
mod blkposition;
mod block;
mod blockhash;
mod blockhashprefix;
mod cents;
mod date;
mod dateindex;
mod decadeindex;
mod difficultyepoch;
mod dollars;
mod emptyaddressdata;
mod emptyaddressindex;
mod emptyoutputindex;
mod feerate;
mod halvingepoch;
mod height;
mod index;
mod indexinfo;
mod inputindex;
mod loadedaddressdata;
mod loadedaddressindex;
mod monthindex;
mod ohlc;
mod opreturnindex;
mod outputindex;
mod outputtype;
mod p2aaddressindex;
mod p2msoutputindex;
mod p2pk33addressindex;
mod p2pk65addressindex;
mod p2pkhaddressindex;
mod p2shaddressindex;
mod p2traddressindex;
mod p2wpkhaddressindex;
mod p2wshaddressindex;
mod pool;
mod poolid;
mod pools;
mod quarterindex;
mod rawlocktime;
mod sats;
mod semesterindex;
mod stored_bool;
mod stored_f32;
mod stored_f64;
mod stored_i16;
mod stored_string;
mod stored_u16;
mod stored_u32;
mod stored_u64;
mod stored_u8;
mod timestamp;
mod treenode;
mod txid;
mod txidprefix;
mod txindex;
mod txversion;
mod typeindex;
mod typeindex_with_outputindex;
mod unit;
mod unknownoutputindex;
mod vin;
mod vout;
mod weekindex;
mod weight;
mod yearindex;
pub use addressbytes::*;
pub use addressbyteshash::*;
pub use anyaddressindex::*;
pub use bitcoin::*;
pub use blkmetadata::*;
pub use blkposition::*;
pub use block::*;
pub use blockhash::*;
pub use blockhashprefix::*;
pub use cents::*;
pub use date::*;
pub use dateindex::*;
pub use decadeindex::*;
pub use difficultyepoch::*;
pub use dollars::*;
pub use emptyaddressdata::*;
pub use emptyaddressindex::*;
pub use emptyoutputindex::*;
pub use feerate::*;
pub use halvingepoch::*;
pub use height::*;
pub use index::*;
pub use indexinfo::*;
pub use inputindex::*;
pub use loadedaddressdata::*;
pub use loadedaddressindex::*;
pub use monthindex::*;
pub use ohlc::*;
pub use opreturnindex::*;
pub use outputindex::*;
pub use outputtype::*;
pub use p2aaddressindex::*;
pub use p2msoutputindex::*;
pub use p2pk33addressindex::*;
pub use p2pk65addressindex::*;
pub use p2pkhaddressindex::*;
pub use p2shaddressindex::*;
pub use p2traddressindex::*;
pub use p2wpkhaddressindex::*;
pub use p2wshaddressindex::*;
pub use pool::*;
pub use poolid::*;
pub use pools::*;
pub use quarterindex::*;
pub use rawlocktime::*;
pub use sats::*;
pub use semesterindex::*;
pub use stored_bool::*;
pub use stored_f32::*;
pub use stored_f64::*;
pub use stored_i16::*;
pub use stored_string::*;
pub use stored_u8::*;
pub use stored_u16::*;
pub use stored_u32::*;
pub use stored_u64::*;
pub use timestamp::*;
pub use treenode::*;
pub use txid::*;
pub use txidprefix::*;
pub use txindex::*;
pub use txversion::*;
pub use typeindex::*;
pub use typeindex_with_outputindex::*;
pub use unit::*;
pub use unknownoutputindex::*;
pub use vin::*;
pub use vout::*;
pub use weekindex::*;
pub use weight::*;
pub use yearindex::*;
#[allow(clippy::result_unit_err)]
pub fn copy_first_4bytes(slice: &[u8]) -> Result<[u8; 4]> {
let mut buf: [u8; 4] = [0; 4];
let buf_len = buf.len();
if slice.len() < buf_len {
return Err(Error::Str("Buffer is too small to convert to 8 bytes"));
}
slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
buf[i] = *r;
});
Ok(buf)
}
#[allow(clippy::result_unit_err)]
pub fn copy_first_8bytes(slice: &[u8]) -> Result<[u8; 8]> {
let mut buf: [u8; 8] = [0; 8];
let buf_len = buf.len();
if slice.len() < buf_len {
return Err(Error::Str("Buffer is too small to convert to 8 bytes"));
}
slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
buf[i] = *r;
});
Ok(buf)
}
crates/brk_structs/src/structs/loadedaddressdata.rs → crates/brk_structs/src/loadedaddressdata.rs
View File
crates/brk_structs/src/structs/loadedaddressindex.rs → crates/brk_structs/src/loadedaddressindex.rs
View File
crates/brk_structs/src/structs/monthindex.rs → crates/brk_structs/src/monthindex.rs
View File
crates/brk_structs/src/structs/ohlc.rs → crates/brk_structs/src/ohlc.rs
View File
crates/brk_structs/src/structs/opreturnindex.rs → crates/brk_structs/src/opreturnindex.rs
View File
crates/brk_structs/src/structs/outputindex.rs → crates/brk_structs/src/outputindex.rs
View File
crates/brk_structs/src/structs/outputtype.rs → crates/brk_structs/src/outputtype.rs
View File
crates/brk_structs/src/structs/p2aaddressindex.rs → crates/brk_structs/src/p2aaddressindex.rs
View File
crates/brk_structs/src/structs/p2msoutputindex.rs → crates/brk_structs/src/p2msoutputindex.rs
View File
crates/brk_structs/src/structs/p2pk33addressindex.rs → crates/brk_structs/src/p2pk33addressindex.rs
View File
crates/brk_structs/src/structs/p2pk65addressindex.rs → crates/brk_structs/src/p2pk65addressindex.rs
View File
crates/brk_structs/src/structs/p2pkhaddressindex.rs → crates/brk_structs/src/p2pkhaddressindex.rs
View File
crates/brk_structs/src/structs/p2shaddressindex.rs → crates/brk_structs/src/p2shaddressindex.rs
View File
crates/brk_structs/src/structs/p2traddressindex.rs → crates/brk_structs/src/p2traddressindex.rs
View File
crates/brk_structs/src/structs/p2wpkhaddressindex.rs → crates/brk_structs/src/p2wpkhaddressindex.rs
View File
crates/brk_structs/src/structs/p2wshaddressindex.rs → crates/brk_structs/src/p2wshaddressindex.rs
View File
crates/brk_structs/src/structs/pool.rs → crates/brk_structs/src/pool.rs
View File
crates/brk_structs/src/structs/poolid.rs → crates/brk_structs/src/poolid.rs
View File
crates/brk_structs/src/structs/pools.rs → crates/brk_structs/src/pools.rs
+1 -1
View File
@@ -4,7 +4,7 @@ use allocative::Allocative;
use crate::{JSONPool, PoolId};
use super::super::Pool;
use super::Pool;
const POOL_COUNT: usize = 158;
crates/brk_structs/src/structs/quarterindex.rs → crates/brk_structs/src/quarterindex.rs
View File
crates/brk_structs/src/structs/rawlocktime.rs → crates/brk_structs/src/rawlocktime.rs
View File
crates/brk_structs/src/structs/sats.rs → crates/brk_structs/src/sats.rs
View File
crates/brk_structs/src/structs/semesterindex.rs → crates/brk_structs/src/semesterindex.rs
View File
crates/brk_structs/src/structs/stored_bool.rs → crates/brk_structs/src/stored_bool.rs
View File
crates/brk_structs/src/structs/stored_f32.rs → crates/brk_structs/src/stored_f32.rs
View File
crates/brk_structs/src/structs/stored_f64.rs → crates/brk_structs/src/stored_f64.rs
View File
crates/brk_structs/src/structs/stored_i16.rs → crates/brk_structs/src/stored_i16.rs
View File
crates/brk_structs/src/structs/stored_string.rs → crates/brk_structs/src/stored_string.rs
View File
crates/brk_structs/src/structs/stored_u16.rs → crates/brk_structs/src/stored_u16.rs
View File
crates/brk_structs/src/structs/stored_u32.rs → crates/brk_structs/src/stored_u32.rs
View File
crates/brk_structs/src/structs/stored_u64.rs → crates/brk_structs/src/stored_u64.rs
View File
crates/brk_structs/src/structs/stored_u8.rs → crates/brk_structs/src/stored_u8.rs
View File
crates/brk_structs/src/structs/mod.rs
-171
View File
@@ -1,171 +0,0 @@
use brk_error::{Error, Result};
mod addressbytes;
mod addressbyteshash;
mod anyaddressindex;
mod bitcoin;
mod blkmetadata;
mod blkposition;
mod block;
mod blockhash;
mod blockhashprefix;
mod cents;
mod date;
mod dateindex;
mod decadeindex;
mod difficultyepoch;
mod dollars;
mod emptyaddressdata;
mod emptyaddressindex;
mod emptyoutputindex;
mod feerate;
mod halvingepoch;
mod height;
mod index;
mod indexinfo;
mod inputindex;
mod loadedaddressdata;
mod loadedaddressindex;
mod monthindex;
mod ohlc;
mod opreturnindex;
mod outputindex;
mod outputtype;
mod p2aaddressindex;
mod p2msoutputindex;
mod p2pk33addressindex;
mod p2pk65addressindex;
mod p2pkhaddressindex;
mod p2shaddressindex;
mod p2traddressindex;
mod p2wpkhaddressindex;
mod p2wshaddressindex;
mod pool;
mod poolid;
mod pools;
mod quarterindex;
mod rawlocktime;
mod sats;
mod semesterindex;
mod stored_bool;
mod stored_f32;
mod stored_f64;
mod stored_i16;
mod stored_string;
mod stored_u16;
mod stored_u32;
mod stored_u64;
mod stored_u8;
mod timestamp;
mod treenode;
mod txid;
mod txidprefix;
mod txindex;
mod txversion;
mod typeindex;
mod typeindex_with_outputindex;
mod unit;
mod unknownoutputindex;
mod vin;
mod vout;
mod weekindex;
mod weight;
mod yearindex;
pub use addressbytes::*;
pub use addressbyteshash::*;
pub use anyaddressindex::*;
pub use bitcoin::*;
pub use blkmetadata::*;
pub use blkposition::*;
pub use block::*;
pub use blockhash::*;
pub use blockhashprefix::*;
pub use cents::*;
pub use date::*;
pub use dateindex::*;
pub use decadeindex::*;
pub use difficultyepoch::*;
pub use dollars::*;
pub use emptyaddressdata::*;
pub use emptyaddressindex::*;
pub use emptyoutputindex::*;
pub use feerate::*;
pub use halvingepoch::*;
pub use height::*;
pub use index::*;
pub use indexinfo::*;
pub use inputindex::*;
pub use loadedaddressdata::*;
pub use loadedaddressindex::*;
pub use monthindex::*;
pub use ohlc::*;
pub use opreturnindex::*;
pub use outputindex::*;
pub use outputtype::*;
pub use p2aaddressindex::*;
pub use p2msoutputindex::*;
pub use p2pk33addressindex::*;
pub use p2pk65addressindex::*;
pub use p2pkhaddressindex::*;
pub use p2shaddressindex::*;
pub use p2traddressindex::*;
pub use p2wpkhaddressindex::*;
pub use p2wshaddressindex::*;
pub use pool::*;
pub use poolid::*;
pub use pools::*;
pub use quarterindex::*;
pub use rawlocktime::*;
pub use sats::*;
pub use semesterindex::*;
pub use stored_bool::*;
pub use stored_f32::*;
pub use stored_f64::*;
pub use stored_i16::*;
pub use stored_string::*;
pub use stored_u8::*;
pub use stored_u16::*;
pub use stored_u32::*;
pub use stored_u64::*;
pub use timestamp::*;
pub use treenode::*;
pub use txid::*;
pub use txidprefix::*;
pub use txindex::*;
pub use txversion::*;
pub use typeindex::*;
pub use typeindex_with_outputindex::*;
pub use unit::*;
pub use unknownoutputindex::*;
pub use vin::*;
pub use vout::*;
pub use weekindex::*;
pub use weight::*;
pub use yearindex::*;
#[allow(clippy::result_unit_err)]
pub fn copy_first_4bytes(slice: &[u8]) -> Result<[u8; 4]> {
let mut buf: [u8; 4] = [0; 4];
let buf_len = buf.len();
if slice.len() < buf_len {
return Err(Error::Str("Buffer is too small to convert to 8 bytes"));
}
slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
buf[i] = *r;
});
Ok(buf)
}
#[allow(clippy::result_unit_err)]
pub fn copy_first_8bytes(slice: &[u8]) -> Result<[u8; 8]> {
let mut buf: [u8; 8] = [0; 8];
let buf_len = buf.len();
if slice.len() < buf_len {
return Err(Error::Str("Buffer is too small to convert to 8 bytes"));
}
slice.iter().take(buf_len).enumerate().for_each(|(i, r)| {
buf[i] = *r;
});
Ok(buf)
}
crates/brk_structs/src/structs/timestamp.rs → crates/brk_structs/src/timestamp.rs
View File
crates/brk_structs/src/structs/treenode.rs → crates/brk_structs/src/treenode.rs
+50 -24
View File
@@ -1,3 +1,10 @@
use std::{collections::BTreeMap, sync::LazyLock};
use schemars::JsonSchema;
use serde::Serialize;
use super::Index;
#[derive(Debug, Clone, Serialize, PartialEq, Eq, JsonSchema)]
#[serde(untagged)]
/// Hierarchical tree node for organizing metrics into categories
@@ -9,6 +16,17 @@ pub enum TreeNode {
Leaf(String),
}
const BASE: &str = "base";
/// List of prefixes to remove during simplification
static PREFIXES: LazyLock<Vec<String>> = LazyLock::new(|| {
["indexes", "timeindexes", "chainindexes"]
.into_iter()
.chain(Index::all().iter().map(|i| i.serialize_long()))
.map(|s| format!("{s}_to_"))
.collect()
});
impl TreeNode {
pub fn is_empty(&self) -> bool {
if let Self::Branch(tree) = self {
@@ -18,8 +36,15 @@ impl TreeNode {
}
}
pub fn as_mut_branch(&mut self) -> &mut BTreeMap<String, TreeNode> {
match self {
Self::Branch(b) => b,
_ => panic!(),
}
}
/// Merges all first-level branches into a single flattened structure.
/// Root-level leaves are placed under "default" key.
/// Root-level leaves are placed under BASE key.
/// Returns None if conflicts are found (same key with incompatible values).
pub fn merge_branches(&self) -> Option<Self> {
let Self::Branch(tree) = self else {
@@ -31,7 +56,7 @@ impl TreeNode {
for node in tree.values() {
match node {
Self::Leaf(value) => {
Self::merge_node(&mut merged, "base", &Self::Leaf(value.clone()))?;
Self::merge_node(&mut merged, BASE, &Self::Leaf(value.clone()))?;
}
Self::Branch(inner) => {
for (key, inner_node) in inner {
@@ -86,20 +111,35 @@ impl TreeNode {
target.insert(key.to_string(), node.clone());
Some(())
}
Some(existing) => match (existing, node) {
Some(existing) => match (&existing, node) {
// Same leaf values: ok
(Self::Leaf(a), Self::Leaf(b)) if a == b => Some(()),
// Different leaf values: conflict
(Self::Leaf(_), Self::Leaf(_)) => None,
// Leaf vs branch: conflict
(Self::Leaf(_), Self::Branch(_)) | (Self::Branch(_), Self::Leaf(_)) => {
// dbg!((&existing, &node));
(Self::Leaf(a), Self::Leaf(b)) => {
eprintln!("Conflict: Different leaf values for key '{key}'");
eprintln!(" Existing: {a:?}");
eprintln!(" New: {b:?}");
None
}
(Self::Leaf(leaf), Self::Branch(branch)) => {
let mut new_branch = BTreeMap::new();
new_branch.insert(BASE.to_string(), Self::Leaf(leaf.clone()));
for (k, v) in branch {
Self::merge_node(&mut new_branch, k, v)?;
}
*existing = Self::Branch(new_branch);
Some(())
}
(Self::Branch(_), Self::Leaf(leaf)) => {
Self::merge_node(existing.as_mut_branch(), BASE, &Self::Leaf(leaf.clone()))?;
Some(())
}
// Both branches: merge recursively
(Self::Branch(existing_inner), Self::Branch(new_inner)) => {
(Self::Branch(_), Self::Branch(new_inner)) => {
for (k, v) in new_inner {
Self::merge_node(existing_inner, k, v)?;
Self::merge_node(existing.as_mut_branch(), k, v)?;
}
Some(())
}
@@ -107,20 +147,6 @@ impl TreeNode {
}
}
/// List of prefixes to remove during simplification
const PREFIXES: &'static [&'static str] = &[
"indexes_to_",
"chainindexes_to_",
"timeindexes_to_",
"txindex_to_",
"height_to_",
"dateindex_to_",
"weekindex_to_",
"difficultyepoch_to_",
"halvingepoch_to_",
// Add more prefixes here
];
/// Recursively simplifies the tree by removing known prefixes from keys.
/// If multiple keys map to the same simplified name, checks for conflicts.
/// Returns None if there are conflicts (same simplified key, different values).
@@ -135,7 +161,7 @@ impl TreeNode {
let simplified_node = node.simplify()?;
// Remove prefixes from the key
let simplified_key = Self::PREFIXES
let simplified_key = PREFIXES
.iter()
.find_map(|prefix| key.strip_prefix(prefix))
.map(String::from)
crates/brk_structs/src/structs/txid.rs → crates/brk_structs/src/txid.rs
View File
crates/brk_structs/src/structs/txidprefix.rs → crates/brk_structs/src/txidprefix.rs
View File
crates/brk_structs/src/structs/txindex.rs → crates/brk_structs/src/txindex.rs
View File
crates/brk_structs/src/structs/txversion.rs → crates/brk_structs/src/txversion.rs
View File
crates/brk_structs/src/structs/typeindex.rs → crates/brk_structs/src/typeindex.rs
View File
crates/brk_structs/src/structs/typeindex_with_outputindex.rs → crates/brk_structs/src/typeindex_with_outputindex.rs
View File
crates/brk_structs/src/structs/unit.rs → crates/brk_structs/src/unit.rs
View File
crates/brk_structs/src/structs/unknownoutputindex.rs → crates/brk_structs/src/unknownoutputindex.rs
View File
crates/brk_structs/src/structs/vin.rs → crates/brk_structs/src/vin.rs
View File
crates/brk_structs/src/structs/vout.rs → crates/brk_structs/src/vout.rs
View File
crates/brk_structs/src/structs/weekindex.rs → crates/brk_structs/src/weekindex.rs
View File
crates/brk_structs/src/structs/weight.rs → crates/brk_structs/src/weight.rs
View File
crates/brk_structs/src/structs/yearindex.rs → crates/brk_structs/src/yearindex.rs
View File