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

global: renames and fixes

Browse Source
This commit is contained in:
nym21
2025-07-08 21:33:18 +02:00
parent 8cc1f8d691
commit f45fb6efe6
39 changed files with 2355 additions and 2270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
crates/brk_core/src/groups/address.rs
View File

@@ -1,45 +1,45 @@
use super::{GroupFilter, GroupedByFromSize, GroupedBySizeRange, GroupedByUpToSize};
use super::{ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, GroupFilter};
#[derive(Default, Clone)]
pub struct AddressGroups<T> {
pub by_from_size: GroupedByFromSize<T>,
pub by_size_range: GroupedBySizeRange<T>,
pub by_up_to_size: GroupedByUpToSize<T>,
pub ge_amount: ByGreatEqualAmount<T>,
pub amount_range: ByAmountRange<T>,
pub lt_amount: ByLowerThanAmount<T>,
}
impl<T> AddressGroups<T> {
pub fn as_mut_vecs(&mut self) -> Vec<&mut T> {
self.by_from_size
self.ge_amount
.as_mut_vec()
.into_iter()
.chain(self.by_size_range.as_mut_vec())
.chain(self.by_up_to_size.as_mut_vec())
.chain(self.amount_range.as_mut_vec())
.chain(self.lt_amount.as_mut_vec())
.collect::<Vec<_>>()
}
pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> {
self.by_size_range
self.amount_range
.as_mut_vec()
.into_iter()
.collect::<Vec<_>>()
}
pub fn as_mut_overlapping_vecs(&mut self) -> Vec<&mut T> {
self.by_up_to_size
self.lt_amount
.as_mut_vec()
.into_iter()
.chain(self.by_from_size.as_mut_vec())
.chain(self.ge_amount.as_mut_vec())
.collect::<Vec<_>>()
}
}
impl<T> AddressGroups<(GroupFilter, T)> {
pub fn vecs(&self) -> Vec<&T> {
self.by_size_range
self.amount_range
.vecs()
.into_iter()
.chain(self.by_up_to_size.vecs())
.chain(self.by_from_size.vecs())
.chain(self.lt_amount.vecs())
.chain(self.ge_amount.vecs())
.collect::<Vec<_>>()
}
}
@@ -47,9 +47,9 @@ impl<T> AddressGroups<(GroupFilter, T)> {
impl<T> From<AddressGroups<T>> for AddressGroups<(GroupFilter, T)> {
fn from(value: AddressGroups<T>) -> Self {
Self {
by_size_range: GroupedBySizeRange::from(value.by_size_range),
by_up_to_size: GroupedByUpToSize::from(value.by_up_to_size),
by_from_size: GroupedByFromSize::from(value.by_from_size),
amount_range: ByAmountRange::from(value.amount_range),
lt_amount: ByLowerThanAmount::from(value.lt_amount),
ge_amount: ByGreatEqualAmount::from(value.ge_amount),
}
}
}

14
crates/brk_core/src/groups/by_address_type.rs
View File

@@ -7,7 +7,7 @@ use super::GroupFilter;
use crate::OutputType;
#[derive(Default, Clone, Debug)]
pub struct GroupedByAddressType<T> {
pub struct ByAddressType<T> {
pub p2pk65: T,
pub p2pk33: T,
pub p2pkh: T,
@@ -18,7 +18,7 @@ pub struct GroupedByAddressType<T> {
pub p2a: T,
}
impl<T> GroupedByAddressType<T> {
impl<T> ByAddressType<T> {
pub fn get(&self, address_type: OutputType) -> Option<&T> {
match address_type {
OutputType::P2PK65 => Some(&self.p2pk65),
@@ -103,7 +103,7 @@ impl<T> GroupedByAddressType<T> {
}
}
impl<T> GroupedByAddressType<(GroupFilter, T)> {
impl<T> ByAddressType<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 8] {
[
&self.p2pk65.1,
@@ -118,8 +118,8 @@ impl<T> GroupedByAddressType<(GroupFilter, T)> {
}
}
impl<T> From<GroupedByAddressType<T>> for GroupedByAddressType<(GroupFilter, T)> {
fn from(value: GroupedByAddressType<T>) -> Self {
impl<T> From<ByAddressType<T>> for ByAddressType<(GroupFilter, T)> {
fn from(value: ByAddressType<T>) -> Self {
Self {
p2pk65: (GroupFilter::Type(OutputType::P2PK65), value.p2pk65),
p2pk33: (GroupFilter::Type(OutputType::P2PK33), value.p2pk33),
@@ -133,7 +133,7 @@ impl<T> From<GroupedByAddressType<T>> for GroupedByAddressType<(GroupFilter, T)>
}
}
impl<T> Add for GroupedByAddressType<T>
impl<T> Add for ByAddressType<T>
where
T: Add<Output = T>,
{
@@ -152,7 +152,7 @@ where
}
}
impl<T> AddAssign for GroupedByAddressType<T>
impl<T> AddAssign for ByAddressType<T>
where
T: AddAssign,
{

51
crates/brk_core/src/groups/by_date_range.rs → crates/brk_core/src/groups/by_age_range.rs
View File

@@ -1,8 +1,8 @@
use super::GroupFilter;
#[derive(Default, Clone)]
pub struct GroupedByDateRange<T> {
pub start_to_1d: T,
pub struct ByAgeRange<T> {
pub up_to_1d: T,
pub _1d_to_1w: T,
pub _1w_to_1m: T,
pub _1m_to_2m: T,
@@ -19,14 +19,15 @@ pub struct GroupedByDateRange<T> {
pub _6y_to_7y: T,
pub _7y_to_8y: T,
pub _8y_to_10y: T,
pub _10y_to_15y: T,
pub _15y_to_end: T,
pub _10y_to_12y: T,
pub _12y_to_15y: T,
pub from_15y: T,
}
impl<T> From<GroupedByDateRange<T>> for GroupedByDateRange<(GroupFilter, T)> {
fn from(value: GroupedByDateRange<T>) -> Self {
impl<T> From<ByAgeRange<T>> for ByAgeRange<(GroupFilter, T)> {
fn from(value: ByAgeRange<T>) -> Self {
Self {
start_to_1d: (GroupFilter::To(1), value.start_to_1d),
up_to_1d: (GroupFilter::LowerThan(1), value.up_to_1d),
_1d_to_1w: (GroupFilter::Range(1..7), value._1d_to_1w),
_1w_to_1m: (GroupFilter::Range(7..30), value._1w_to_1m),
_1m_to_2m: (GroupFilter::Range(30..2 * 30), value._1m_to_2m),
@@ -43,16 +44,17 @@ impl<T> From<GroupedByDateRange<T>> for GroupedByDateRange<(GroupFilter, T)> {
_6y_to_7y: (GroupFilter::Range(6 * 365..7 * 365), value._6y_to_7y),
_7y_to_8y: (GroupFilter::Range(7 * 365..8 * 365), value._7y_to_8y),
_8y_to_10y: (GroupFilter::Range(8 * 365..10 * 365), value._8y_to_10y),
_10y_to_15y: (GroupFilter::Range(10 * 365..15 * 365), value._10y_to_15y),
_15y_to_end: (GroupFilter::From(15 * 365), value._15y_to_end),
_10y_to_12y: (GroupFilter::Range(10 * 365..12 * 365), value._10y_to_12y),
_12y_to_15y: (GroupFilter::Range(12 * 365..15 * 365), value._12y_to_15y),
from_15y: (GroupFilter::GreaterOrEqual(15 * 365), value.from_15y),
}
}
}
impl<T> GroupedByDateRange<T> {
pub fn as_vec(&mut self) -> [&T; 19] {
impl<T> ByAgeRange<T> {
pub fn as_vec(&mut self) -> [&T; 20] {
[
&self.start_to_1d,
&self.up_to_1d,
&self._1d_to_1w,
&self._1w_to_1m,
&self._1m_to_2m,
@@ -69,14 +71,15 @@ impl<T> GroupedByDateRange<T> {
&self._6y_to_7y,
&self._7y_to_8y,
&self._8y_to_10y,
&self._10y_to_15y,
&self._15y_to_end,
&self._10y_to_12y,
&self._12y_to_15y,
&self.from_15y,
]
}
pub fn as_mut_vec(&mut self) -> [&mut T; 19] {
pub fn as_mut_vec(&mut self) -> [&mut T; 20] {
[
&mut self.start_to_1d,
&mut self.up_to_1d,
&mut self._1d_to_1w,
&mut self._1w_to_1m,
&mut self._1m_to_2m,
@@ -93,16 +96,17 @@ impl<T> GroupedByDateRange<T> {
&mut self._6y_to_7y,
&mut self._7y_to_8y,
&mut self._8y_to_10y,
&mut self._10y_to_15y,
&mut self._15y_to_end,
&mut self._10y_to_12y,
&mut self._12y_to_15y,
&mut self.from_15y,
]
}
}
impl<T> GroupedByDateRange<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 19] {
impl<T> ByAgeRange<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 20] {
[
&self.start_to_1d.1,
&self.up_to_1d.1,
&self._1d_to_1w.1,
&self._1w_to_1m.1,
&self._1m_to_2m.1,
@@ -119,8 +123,9 @@ impl<T> GroupedByDateRange<(GroupFilter, T)> {
&self._6y_to_7y.1,
&self._7y_to_8y.1,
&self._8y_to_10y.1,
&self._10y_to_15y.1,
&self._15y_to_end.1,
&self._10y_to_12y.1,
&self._12y_to_15y.1,
&self.from_15y.1,
]
}
}

257
crates/brk_core/src/groups/by_amount_range.rs Normal file
View File

@@ -0,0 +1,257 @@
use std::ops::{Add, AddAssign};
use crate::Sats;
use super::GroupFilter;
#[derive(Debug, Default, Clone)]
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<(GroupFilter, T)> {
fn from(value: ByAmountRange<T>) -> Self {
#[allow(clippy::inconsistent_digit_grouping)]
Self {
_0sats: (GroupFilter::LowerThan(Sats::_1.into()), value._0sats),
_1sat_to_10sats: (
GroupFilter::Range(Sats::_1.into()..Sats::_10.into()),
value._1sat_to_10sats,
),
_10sats_to_100sats: (
GroupFilter::Range(Sats::_10.into()..Sats::_100.into()),
value._10sats_to_100sats,
),
_100sats_to_1k_sats: (
GroupFilter::Range(Sats::_100.into()..Sats::_1K.into()),
value._100sats_to_1k_sats,
),
_1k_sats_to_10k_sats: (
GroupFilter::Range(Sats::_1K.into()..Sats::_10K.into()),
value._1k_sats_to_10k_sats,
),
_10k_sats_to_100k_sats: (
GroupFilter::Range(Sats::_10K.into()..Sats::_100K.into()),
value._10k_sats_to_100k_sats,
),
_100k_sats_to_1m_sats: (
GroupFilter::Range(Sats::_100K.into()..Sats::_1M.into()),
value._100k_sats_to_1m_sats,
),
_1m_sats_to_10m_sats: (
GroupFilter::Range(Sats::_1M.into()..Sats::_10M.into()),
value._1m_sats_to_10m_sats,
),
_10m_sats_to_1btc: (
GroupFilter::Range(Sats::_10M.into()..Sats::_1BTC.into()),
value._10m_sats_to_1btc,
),
_1btc_to_10btc: (
GroupFilter::Range(Sats::_1BTC.into()..Sats::_10BTC.into()),
value._1btc_to_10btc,
),
_10btc_to_100btc: (
GroupFilter::Range(Sats::_10BTC.into()..Sats::_100BTC.into()),
value._10btc_to_100btc,
),
_100btc_to_1k_btc: (
GroupFilter::Range(Sats::_100BTC.into()..Sats::_1K_BTC.into()),
value._100btc_to_1k_btc,
),
_1k_btc_to_10k_btc: (
GroupFilter::Range(Sats::_1K_BTC.into()..Sats::_10K_BTC.into()),
value._1k_btc_to_10k_btc,
),
_10k_btc_to_100k_btc: (
GroupFilter::Range(Sats::_10K_BTC.into()..Sats::_100K_BTC.into()),
value._10k_btc_to_100k_btc,
),
_100k_btc_or_more: (
GroupFilter::GreaterOrEqual(Sats::_100K_BTC.into()),
value._100k_btc_or_more,
),
}
}
}
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 as_vec(&self) -> [&T; 15] {
[
&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,
]
}
pub fn as_typed_vec(&self) -> [(Sats, &T); 15] {
[
(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),
]
}
pub fn as_mut_vec(&mut self) -> [&mut T; 15] {
[
&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,
]
}
}
impl<T> ByAmountRange<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 15] {
[
&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,
]
}
}
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;
}
}

10
crates/brk_core/src/groups/by_epoch.rs
View File

@@ -3,7 +3,7 @@ use crate::{HalvingEpoch, Height};
use super::GroupFilter;
#[derive(Default, Clone)]
pub struct GroupedByEpoch<T> {
pub struct ByEpoch<T> {
pub _0: T,
pub _1: T,
pub _2: T,
@@ -11,8 +11,8 @@ pub struct GroupedByEpoch<T> {
pub _4: T,
}
impl<T> From<GroupedByEpoch<T>> for GroupedByEpoch<(GroupFilter, T)> {
fn from(value: GroupedByEpoch<T>) -> Self {
impl<T> From<ByEpoch<T>> for ByEpoch<(GroupFilter, T)> {
fn from(value: ByEpoch<T>) -> Self {
Self {
_0: (GroupFilter::Epoch(HalvingEpoch::new(0)), value._0),
_1: (GroupFilter::Epoch(HalvingEpoch::new(1)), value._1),
@@ -23,7 +23,7 @@ impl<T> From<GroupedByEpoch<T>> for GroupedByEpoch<(GroupFilter, T)> {
}
}
impl<T> GroupedByEpoch<T> {
impl<T> ByEpoch<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 5] {
[
&mut self._0,
@@ -52,7 +52,7 @@ impl<T> GroupedByEpoch<T> {
}
}
impl<T> GroupedByEpoch<(GroupFilter, T)> {
impl<T> ByEpoch<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 5] {
[&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1]
}

80
crates/brk_core/src/groups/by_from_size.rs
View File

@@ -1,80 +0,0 @@
use crate::Sats;
use super::GroupFilter;
#[derive(Default, Clone)]
pub struct GroupedByFromSize<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> GroupedByFromSize<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 13] {
[
&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,
]
}
}
impl<T> GroupedByFromSize<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 13] {
[
&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,
]
}
}
impl<T> From<GroupedByFromSize<T>> for GroupedByFromSize<(GroupFilter, T)> {
fn from(value: GroupedByFromSize<T>) -> Self {
Self {
_1sat: (GroupFilter::From(Sats::_1.into()), value._1sat),
_10sats: (GroupFilter::From(Sats::_10.into()), value._10sats),
_100sats: (GroupFilter::From(Sats::_100.into()), value._100sats),
_1k_sats: (GroupFilter::From(Sats::_1K.into()), value._1k_sats),
_10k_sats: (GroupFilter::From(Sats::_10K.into()), value._10k_sats),
_100k_sats: (GroupFilter::From(Sats::_100K.into()), value._100k_sats),
_1m_sats: (GroupFilter::From(Sats::_1M.into()), value._1m_sats),
_10m_sats: (GroupFilter::From(Sats::_10M.into()), value._10m_sats),
_1btc: (GroupFilter::From(Sats::_1BTC.into()), value._1btc),
_10btc: (GroupFilter::From(Sats::_10BTC.into()), value._10btc),
_100btc: (GroupFilter::From(Sats::_100BTC.into()), value._100btc),
_1k_btc: (GroupFilter::From(Sats::_1K_BTC.into()), value._1k_btc),
_10k_btc: (GroupFilter::From(Sats::_10K_BTC.into()), value._10k_btc),
}
}
}

110
crates/brk_core/src/groups/by_ge_amount.rs Normal file
View File

@@ -0,0 +1,110 @@
use crate::Sats;
use super::GroupFilter;
#[derive(Default, Clone)]
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 as_mut_vec(&mut self) -> [&mut T; 13] {
[
&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,
]
}
}
impl<T> ByGreatEqualAmount<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 13] {
[
&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,
]
}
}
impl<T> From<ByGreatEqualAmount<T>> for ByGreatEqualAmount<(GroupFilter, T)> {
fn from(value: ByGreatEqualAmount<T>) -> Self {
Self {
_1sat: (GroupFilter::GreaterOrEqual(Sats::_1.into()), value._1sat),
_10sats: (GroupFilter::GreaterOrEqual(Sats::_10.into()), value._10sats),
_100sats: (
GroupFilter::GreaterOrEqual(Sats::_100.into()),
value._100sats,
),
_1k_sats: (
GroupFilter::GreaterOrEqual(Sats::_1K.into()),
value._1k_sats,
),
_10k_sats: (
GroupFilter::GreaterOrEqual(Sats::_10K.into()),
value._10k_sats,
),
_100k_sats: (
GroupFilter::GreaterOrEqual(Sats::_100K.into()),
value._100k_sats,
),
_1m_sats: (
GroupFilter::GreaterOrEqual(Sats::_1M.into()),
value._1m_sats,
),
_10m_sats: (
GroupFilter::GreaterOrEqual(Sats::_10M.into()),
value._10m_sats,
),
_1btc: (GroupFilter::GreaterOrEqual(Sats::_1BTC.into()), value._1btc),
_10btc: (
GroupFilter::GreaterOrEqual(Sats::_10BTC.into()),
value._10btc,
),
_100btc: (
GroupFilter::GreaterOrEqual(Sats::_100BTC.into()),
value._100btc,
),
_1k_btc: (
GroupFilter::GreaterOrEqual(Sats::_1K_BTC.into()),
value._1k_btc,
),
_10k_btc: (
GroupFilter::GreaterOrEqual(Sats::_10K_BTC.into()),
value._10k_btc,
),
}
}
}

86
crates/brk_core/src/groups/by_lt_amount.rs Normal file
View File

@@ -0,0 +1,86 @@
use crate::Sats;
use super::GroupFilter;
#[derive(Default, Clone)]
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 as_mut_vec(&mut self) -> [&mut T; 13] {
[
&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,
]
}
}
impl<T> ByLowerThanAmount<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 13] {
[
&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,
]
}
}
impl<T> From<ByLowerThanAmount<T>> for ByLowerThanAmount<(GroupFilter, T)> {
fn from(value: ByLowerThanAmount<T>) -> Self {
Self {
_10sats: (GroupFilter::LowerThan(Sats::_10.into()), value._10sats),
_100sats: (GroupFilter::LowerThan(Sats::_100.into()), value._100sats),
_1k_sats: (GroupFilter::LowerThan(Sats::_1K.into()), value._1k_sats),
_10k_sats: (GroupFilter::LowerThan(Sats::_10K.into()), value._10k_sats),
_100k_sats: (GroupFilter::LowerThan(Sats::_100K.into()), value._100k_sats),
_1m_sats: (GroupFilter::LowerThan(Sats::_1M.into()), value._1m_sats),
_10m_sats: (GroupFilter::LowerThan(Sats::_10M.into()), value._10m_sats),
_1btc: (GroupFilter::LowerThan(Sats::_1BTC.into()), value._1btc),
_10btc: (GroupFilter::LowerThan(Sats::_10BTC.into()), value._10btc),
_100btc: (GroupFilter::LowerThan(Sats::_100BTC.into()), value._100btc),
_1k_btc: (GroupFilter::LowerThan(Sats::_1K_BTC.into()), value._1k_btc),
_10k_btc: (
GroupFilter::LowerThan(Sats::_10K_BTC.into()),
value._10k_btc,
),
_100k_btc: (
GroupFilter::LowerThan(Sats::_100K_BTC.into()),
value._100k_btc,
),
}
}
}

52
crates/brk_core/src/groups/by_from_date.rs → crates/brk_core/src/groups/by_max_age.rs
View File

@@ -1,8 +1,7 @@
use super::GroupFilter;
#[derive(Default, Clone)]
pub struct GroupedByFromDate<T> {
pub _1d: T,
pub struct ByMaxAge<T> {
pub _1w: T,
pub _1m: T,
pub _2m: T,
@@ -19,13 +18,13 @@ pub struct GroupedByFromDate<T> {
pub _7y: T,
pub _8y: T,
pub _10y: T,
pub _12y: T,
pub _15y: T,
}
impl<T> GroupedByFromDate<T> {
impl<T> ByMaxAge<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
[
&mut self._1d,
&mut self._1w,
&mut self._1m,
&mut self._2m,
@@ -42,15 +41,15 @@ impl<T> GroupedByFromDate<T> {
&mut self._7y,
&mut self._8y,
&mut self._10y,
&mut self._12y,
&mut self._15y,
]
}
}
impl<T> GroupedByFromDate<(GroupFilter, T)> {
impl<T> ByMaxAge<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 18] {
[
&self._1d.1,
&self._1w.1,
&self._1m.1,
&self._2m.1,
@@ -67,32 +66,33 @@ impl<T> GroupedByFromDate<(GroupFilter, T)> {
&self._7y.1,
&self._8y.1,
&self._10y.1,
&self._12y.1,
&self._15y.1,
]
}
}
impl<T> From<GroupedByFromDate<T>> for GroupedByFromDate<(GroupFilter, T)> {
fn from(value: GroupedByFromDate<T>) -> Self {
impl<T> From<ByMaxAge<T>> for ByMaxAge<(GroupFilter, T)> {
fn from(value: ByMaxAge<T>) -> Self {
Self {
_1d: (GroupFilter::From(1), value._1d),
_1w: (GroupFilter::From(7), value._1w),
_1m: (GroupFilter::From(30), value._1m),
_2m: (GroupFilter::From(2 * 30), value._2m),
_3m: (GroupFilter::From(3 * 30), value._3m),
_4m: (GroupFilter::From(4 * 30), value._4m),
_5m: (GroupFilter::From(5 * 30), value._5m),
_6m: (GroupFilter::From(6 * 30), value._6m),
_1y: (GroupFilter::From(365), value._1y),
_2y: (GroupFilter::From(2 * 365), value._2y),
_3y: (GroupFilter::From(3 * 365), value._3y),
_4y: (GroupFilter::From(4 * 365), value._4y),
_5y: (GroupFilter::From(5 * 365), value._5y),
_6y: (GroupFilter::From(6 * 365), value._6y),
_7y: (GroupFilter::From(7 * 365), value._7y),
_8y: (GroupFilter::From(8 * 365), value._8y),
_10y: (GroupFilter::From(10 * 365), value._10y),
_15y: (GroupFilter::From(15 * 365), value._15y),
_1w: (GroupFilter::LowerThan(7), value._1w),
_1m: (GroupFilter::LowerThan(30), value._1m),
_2m: (GroupFilter::LowerThan(2 * 30), value._2m),
_3m: (GroupFilter::LowerThan(3 * 30), value._3m),
_4m: (GroupFilter::LowerThan(4 * 30), value._4m),
_5m: (GroupFilter::LowerThan(5 * 30), value._5m),
_6m: (GroupFilter::LowerThan(6 * 30), value._6m),
_1y: (GroupFilter::LowerThan(365), value._1y),
_2y: (GroupFilter::LowerThan(2 * 365), value._2y),
_3y: (GroupFilter::LowerThan(3 * 365), value._3y),
_4y: (GroupFilter::LowerThan(4 * 365), value._4y),
_5y: (GroupFilter::LowerThan(5 * 365), value._5y),
_6y: (GroupFilter::LowerThan(6 * 365), value._6y),
_7y: (GroupFilter::LowerThan(7 * 365), value._7y),
_8y: (GroupFilter::LowerThan(8 * 365), value._8y),
_10y: (GroupFilter::LowerThan(10 * 365), value._10y),
_12y: (GroupFilter::LowerThan(12 * 365), value._12y),
_15y: (GroupFilter::LowerThan(15 * 365), value._15y),
}
}
}

98
crates/brk_core/src/groups/by_min_age.rs Normal file
View File

@@ -0,0 +1,98 @@
use super::GroupFilter;
#[derive(Default, Clone)]
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 as_mut_vec(&mut self) -> [&mut T; 18] {
[
&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,
]
}
}
impl<T> ByMinAge<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 18] {
[
&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,
]
}
}
impl<T> From<ByMinAge<T>> for ByMinAge<(GroupFilter, T)> {
fn from(value: ByMinAge<T>) -> Self {
Self {
_1d: (GroupFilter::GreaterOrEqual(1), value._1d),
_1w: (GroupFilter::GreaterOrEqual(7), value._1w),
_1m: (GroupFilter::GreaterOrEqual(30), value._1m),
_2m: (GroupFilter::GreaterOrEqual(2 * 30), value._2m),
_3m: (GroupFilter::GreaterOrEqual(3 * 30), value._3m),
_4m: (GroupFilter::GreaterOrEqual(4 * 30), value._4m),
_5m: (GroupFilter::GreaterOrEqual(5 * 30), value._5m),
_6m: (GroupFilter::GreaterOrEqual(6 * 30), value._6m),
_1y: (GroupFilter::GreaterOrEqual(365), value._1y),
_2y: (GroupFilter::GreaterOrEqual(2 * 365), value._2y),
_3y: (GroupFilter::GreaterOrEqual(3 * 365), value._3y),
_4y: (GroupFilter::GreaterOrEqual(4 * 365), value._4y),
_5y: (GroupFilter::GreaterOrEqual(5 * 365), value._5y),
_6y: (GroupFilter::GreaterOrEqual(6 * 365), value._6y),
_7y: (GroupFilter::GreaterOrEqual(7 * 365), value._7y),
_8y: (GroupFilter::GreaterOrEqual(8 * 365), value._8y),
_10y: (GroupFilter::GreaterOrEqual(10 * 365), value._10y),
_12y: (GroupFilter::GreaterOrEqual(12 * 365), value._12y),
}
}
}

256
crates/brk_core/src/groups/by_size_range.rs
View File

@@ -1,256 +0,0 @@
use std::ops::{Add, AddAssign};
use crate::Sats;
use super::GroupFilter;
#[derive(Debug, Default, Clone)]
pub struct GroupedBySizeRange<T> {
pub _0sats: T,
pub from_1sat_to_10sats: T,
pub from_10sats_to_100sats: T,
pub from_100sats_to_1_000sats: T,
pub from_1_000sats_to_10_000sats: T,
pub from_10_000sats_to_100_000sats: T,
pub from_100_000sats_to_1_000_000sats: T,
pub from_1_000_000sats_to_10_000_000sats: T,
pub from_10_000_000sats_to_1btc: T,
pub from_1btc_to_10btc: T,
pub from_10btc_to_100btc: T,
pub from_100btc_to_1_000btc: T,
pub from_1_000btc_to_10_000btc: T,
pub from_10_000btc_to_100_000btc: T,
pub from_100_000btc: T,
}
impl<T> From<GroupedBySizeRange<T>> for GroupedBySizeRange<(GroupFilter, T)> {
fn from(value: GroupedBySizeRange<T>) -> Self {
#[allow(clippy::inconsistent_digit_grouping)]
Self {
_0sats: (GroupFilter::To(1), value._0sats),
from_1sat_to_10sats: (GroupFilter::Range(1..10), value.from_1sat_to_10sats),
from_10sats_to_100sats: (GroupFilter::Range(10..100), value.from_10sats_to_100sats),
from_100sats_to_1_000sats: (
GroupFilter::Range(100..1_000),
value.from_100sats_to_1_000sats,
),
from_1_000sats_to_10_000sats: (
GroupFilter::Range(1_000..10_000),
value.from_1_000sats_to_10_000sats,
),
from_10_000sats_to_100_000sats: (
GroupFilter::Range(10_000..100_000),
value.from_10_000sats_to_100_000sats,
),
from_100_000sats_to_1_000_000sats: (
GroupFilter::Range(100_000..1_000_000),
value.from_100_000sats_to_1_000_000sats,
),
from_1_000_000sats_to_10_000_000sats: (
GroupFilter::Range(1_000_000..10_000_000),
value.from_1_000_000sats_to_10_000_000sats,
),
from_10_000_000sats_to_1btc: (
GroupFilter::Range(10_000_000..1_00_000_000),
value.from_10_000_000sats_to_1btc,
),
from_1btc_to_10btc: (
GroupFilter::Range(1_00_000_000..10_00_000_000),
value.from_1btc_to_10btc,
),
from_10btc_to_100btc: (
GroupFilter::Range(10_00_000_000..100_00_000_000),
value.from_10btc_to_100btc,
),
from_100btc_to_1_000btc: (
GroupFilter::Range(100_00_000_000..1_000_00_000_000),
value.from_100btc_to_1_000btc,
),
from_1_000btc_to_10_000btc: (
GroupFilter::Range(1_000_00_000_000..10_000_00_000_000),
value.from_1_000btc_to_10_000btc,
),
from_10_000btc_to_100_000btc: (
GroupFilter::Range(10_000_00_000_000..100_000_00_000_000),
value.from_10_000btc_to_100_000btc,
),
from_100_000btc: (GroupFilter::From(100_000_00_000_000), value.from_100_000btc),
}
}
}
impl<T> GroupedBySizeRange<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.from_1sat_to_10sats
} else if value < Sats::_100 {
&mut self.from_10sats_to_100sats
} else if value < Sats::_1K {
&mut self.from_100sats_to_1_000sats
} else if value < Sats::_10K {
&mut self.from_1_000sats_to_10_000sats
} else if value < Sats::_100K {
&mut self.from_10_000sats_to_100_000sats
} else if value < Sats::_1M {
&mut self.from_100_000sats_to_1_000_000sats
} else if value < Sats::_10M {
&mut self.from_1_000_000sats_to_10_000_000sats
} else if value < Sats::_1BTC {
&mut self.from_10_000_000sats_to_1btc
} else if value < Sats::_10BTC {
&mut self.from_1btc_to_10btc
} else if value < Sats::_100BTC {
&mut self.from_10btc_to_100btc
} else if value < Sats::_1K_BTC {
&mut self.from_100btc_to_1_000btc
} else if value < Sats::_10K_BTC {
&mut self.from_1_000btc_to_10_000btc
} else if value < Sats::_100K_BTC {
&mut self.from_10_000btc_to_100_000btc
} else {
&mut self.from_100_000btc
}
}
pub fn as_vec(&self) -> [&T; 15] {
[
&self._0sats,
&self.from_1sat_to_10sats,
&self.from_10sats_to_100sats,
&self.from_100sats_to_1_000sats,
&self.from_1_000sats_to_10_000sats,
&self.from_10_000sats_to_100_000sats,
&self.from_100_000sats_to_1_000_000sats,
&self.from_1_000_000sats_to_10_000_000sats,
&self.from_10_000_000sats_to_1btc,
&self.from_1btc_to_10btc,
&self.from_10btc_to_100btc,
&self.from_100btc_to_1_000btc,
&self.from_1_000btc_to_10_000btc,
&self.from_10_000btc_to_100_000btc,
&self.from_100_000btc,
]
}
pub fn as_typed_vec(&self) -> [(Sats, &T); 15] {
[
(Sats::ZERO, &self._0sats),
(Sats::_1, &self.from_1sat_to_10sats),
(Sats::_10, &self.from_10sats_to_100sats),
(Sats::_100, &self.from_100sats_to_1_000sats),
(Sats::_1K, &self.from_1_000sats_to_10_000sats),
(Sats::_10K, &self.from_10_000sats_to_100_000sats),
(Sats::_100K, &self.from_100_000sats_to_1_000_000sats),
(Sats::_1M, &self.from_1_000_000sats_to_10_000_000sats),
(Sats::_10M, &self.from_10_000_000sats_to_1btc),
(Sats::_1BTC, &self.from_1btc_to_10btc),
(Sats::_10BTC, &self.from_10btc_to_100btc),
(Sats::_100BTC, &self.from_100btc_to_1_000btc),
(Sats::_1K_BTC, &self.from_1_000btc_to_10_000btc),
(Sats::_10K_BTC, &self.from_10_000btc_to_100_000btc),
(Sats::_100K_BTC, &self.from_100_000btc),
]
}
pub fn as_mut_vec(&mut self) -> [&mut T; 15] {
[
&mut self._0sats,
&mut self.from_1sat_to_10sats,
&mut self.from_10sats_to_100sats,
&mut self.from_100sats_to_1_000sats,
&mut self.from_1_000sats_to_10_000sats,
&mut self.from_10_000sats_to_100_000sats,
&mut self.from_100_000sats_to_1_000_000sats,
&mut self.from_1_000_000sats_to_10_000_000sats,
&mut self.from_10_000_000sats_to_1btc,
&mut self.from_1btc_to_10btc,
&mut self.from_10btc_to_100btc,
&mut self.from_100btc_to_1_000btc,
&mut self.from_1_000btc_to_10_000btc,
&mut self.from_10_000btc_to_100_000btc,
&mut self.from_100_000btc,
]
}
}
impl<T> GroupedBySizeRange<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 15] {
[
&self._0sats.1,
&self.from_1sat_to_10sats.1,
&self.from_10sats_to_100sats.1,
&self.from_100sats_to_1_000sats.1,
&self.from_1_000sats_to_10_000sats.1,
&self.from_10_000sats_to_100_000sats.1,
&self.from_100_000sats_to_1_000_000sats.1,
&self.from_1_000_000sats_to_10_000_000sats.1,
&self.from_10_000_000sats_to_1btc.1,
&self.from_1btc_to_10btc.1,
&self.from_10btc_to_100btc.1,
&self.from_100btc_to_1_000btc.1,
&self.from_1_000btc_to_10_000btc.1,
&self.from_10_000btc_to_100_000btc.1,
&self.from_100_000btc.1,
]
}
}
impl<T> Add for GroupedBySizeRange<T>
where
T: Add<Output = T>,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {
_0sats: self._0sats + rhs._0sats,
from_1sat_to_10sats: self.from_1sat_to_10sats + rhs.from_1sat_to_10sats,
from_10sats_to_100sats: self.from_10sats_to_100sats + rhs.from_10sats_to_100sats,
from_100sats_to_1_000sats: self.from_100sats_to_1_000sats
+ rhs.from_100sats_to_1_000sats,
from_1_000sats_to_10_000sats: self.from_1_000sats_to_10_000sats
+ rhs.from_1_000sats_to_10_000sats,
from_10_000sats_to_100_000sats: self.from_10_000sats_to_100_000sats
+ rhs.from_10_000sats_to_100_000sats,
from_100_000sats_to_1_000_000sats: self.from_100_000sats_to_1_000_000sats
+ rhs.from_100_000sats_to_1_000_000sats,
from_1_000_000sats_to_10_000_000sats: self.from_1_000_000sats_to_10_000_000sats
+ rhs.from_1_000_000sats_to_10_000_000sats,
from_10_000_000sats_to_1btc: self.from_10_000_000sats_to_1btc
+ rhs.from_10_000_000sats_to_1btc,
from_1btc_to_10btc: self.from_1btc_to_10btc + rhs.from_1btc_to_10btc,
from_10btc_to_100btc: self.from_10btc_to_100btc + rhs.from_10btc_to_100btc,
from_100btc_to_1_000btc: self.from_100btc_to_1_000btc + rhs.from_100btc_to_1_000btc,
from_1_000btc_to_10_000btc: self.from_1_000btc_to_10_000btc
+ rhs.from_1_000btc_to_10_000btc,
from_10_000btc_to_100_000btc: self.from_10_000btc_to_100_000btc
+ rhs.from_10_000btc_to_100_000btc,
from_100_000btc: self.from_100_000btc + rhs.from_100_000btc,
}
}
}
impl<T> AddAssign for GroupedBySizeRange<T>
where
T: AddAssign,
{
fn add_assign(&mut self, rhs: Self) {
self._0sats += rhs._0sats;
self.from_1sat_to_10sats += rhs.from_1sat_to_10sats;
self.from_10sats_to_100sats += rhs.from_10sats_to_100sats;
self.from_100sats_to_1_000sats += rhs.from_100sats_to_1_000sats;
self.from_1_000sats_to_10_000sats += rhs.from_1_000sats_to_10_000sats;
self.from_10_000sats_to_100_000sats += rhs.from_10_000sats_to_100_000sats;
self.from_100_000sats_to_1_000_000sats += rhs.from_100_000sats_to_1_000_000sats;
self.from_1_000_000sats_to_10_000_000sats += rhs.from_1_000_000sats_to_10_000_000sats;
self.from_10_000_000sats_to_1btc += rhs.from_10_000_000sats_to_1btc;
self.from_1btc_to_10btc += rhs.from_1btc_to_10btc;
self.from_10btc_to_100btc += rhs.from_10btc_to_100btc;
self.from_100btc_to_1_000btc += rhs.from_100btc_to_1_000btc;
self.from_1_000btc_to_10_000btc += rhs.from_1_000btc_to_10_000btc;
self.from_10_000btc_to_100_000btc += rhs.from_10_000btc_to_100_000btc;
self.from_100_000btc += rhs.from_100_000btc;
}
}

14
crates/brk_core/src/groups/by_spendable_type.rs
View File

@@ -5,7 +5,7 @@ use crate::OutputType;
use super::GroupFilter;
#[derive(Default, Clone, Debug)]
pub struct GroupedBySpendableType<T> {
pub struct BySpendableType<T> {
pub p2pk65: T,
pub p2pk33: T,
pub p2pkh: T,
@@ -19,7 +19,7 @@ pub struct GroupedBySpendableType<T> {
pub empty: T,
}
impl<T> GroupedBySpendableType<T> {
impl<T> BySpendableType<T> {
pub fn get_mut(&mut self, output_type: OutputType) -> &mut T {
match output_type {
OutputType::P2PK65 => &mut self.p2pk65,
@@ -70,7 +70,7 @@ impl<T> GroupedBySpendableType<T> {
}
}
impl<T> GroupedBySpendableType<(GroupFilter, T)> {
impl<T> BySpendableType<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 11] {
[
&self.p2pk65.1,
@@ -88,8 +88,8 @@ impl<T> GroupedBySpendableType<(GroupFilter, T)> {
}
}
impl<T> From<GroupedBySpendableType<T>> for GroupedBySpendableType<(GroupFilter, T)> {
fn from(value: GroupedBySpendableType<T>) -> Self {
impl<T> From<BySpendableType<T>> for BySpendableType<(GroupFilter, T)> {
fn from(value: BySpendableType<T>) -> Self {
Self {
p2pk65: (GroupFilter::Type(OutputType::P2PK65), value.p2pk65),
p2pk33: (GroupFilter::Type(OutputType::P2PK33), value.p2pk33),
@@ -106,7 +106,7 @@ impl<T> From<GroupedBySpendableType<T>> for GroupedBySpendableType<(GroupFilter,
}
}
impl<T> Add for GroupedBySpendableType<T>
impl<T> Add for BySpendableType<T>
where
T: Add<Output = T>,
{
@@ -128,7 +128,7 @@ where
}
}
impl<T> AddAssign for GroupedBySpendableType<T>
impl<T> AddAssign for BySpendableType<T>
where
T: AddAssign,
{

14
crates/brk_core/src/groups/by_term.rs
View File

@@ -1,28 +1,28 @@
use super::GroupFilter;
#[derive(Default, Clone)]
pub struct GroupedByTerm<T> {
pub struct ByTerm<T> {
pub short: T,
pub long: T,
}
impl<T> GroupedByTerm<T> {
impl<T> ByTerm<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 2] {
[&mut self.short, &mut self.long]
}
}
impl<T> GroupedByTerm<(GroupFilter, T)> {
impl<T> ByTerm<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 2] {
[&self.short.1, &self.long.1]
}
}
impl<T> From<GroupedByTerm<T>> for GroupedByTerm<(GroupFilter, T)> {
fn from(value: GroupedByTerm<T>) -> Self {
impl<T> From<ByTerm<T>> for ByTerm<(GroupFilter, T)> {
fn from(value: ByTerm<T>) -> Self {
Self {
short: (GroupFilter::To(5 * 30), value.short),
long: (GroupFilter::From(5 * 30), value.long),
short: (GroupFilter::LowerThan(5 * 30), value.short),
long: (GroupFilter::GreaterOrEqual(5 * 30), value.long),
}
}
}

6
crates/brk_core/src/groups/by_type.rs
View File

@@ -2,12 +2,12 @@ use std::ops::{Add, AddAssign};
use crate::OutputType;
use super::{GroupedBySpendableType, GroupedByUnspendableType};
use super::{BySpendableType, ByUnspendableType};
#[derive(Default, Clone, Debug)]
pub struct GroupedByType<T> {
pub spendable: GroupedBySpendableType<T>,
pub unspendable: GroupedByUnspendableType<T>,
pub spendable: BySpendableType<T>,
pub unspendable: ByUnspendableType<T>,
}
impl<T> GroupedByType<T> {

8
crates/brk_core/src/groups/by_unspendable_type.rs
View File

@@ -1,17 +1,17 @@
use std::ops::{Add, AddAssign};
#[derive(Default, Clone, Debug)]
pub struct GroupedByUnspendableType<T> {
pub struct ByUnspendableType<T> {
pub opreturn: T,
}
impl<T> GroupedByUnspendableType<T> {
impl<T> ByUnspendableType<T> {
pub fn as_vec(&self) -> [&T; 1] {
[&self.opreturn]
}
}
impl<T> Add for GroupedByUnspendableType<T>
impl<T> Add for ByUnspendableType<T>
where
T: Add<Output = T>,
{
@@ -23,7 +23,7 @@ where
}
}
impl<T> AddAssign for GroupedByUnspendableType<T>
impl<T> AddAssign for ByUnspendableType<T>
where
T: AddAssign,
{

98
crates/brk_core/src/groups/by_up_to_date.rs
View File

@@ -1,98 +0,0 @@
use super::GroupFilter;
#[derive(Default, Clone)]
pub struct GroupedByUpToDate<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 _15y: T,
}
impl<T> GroupedByUpToDate<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
[
&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._15y,
]
}
}
impl<T> GroupedByUpToDate<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 18] {
[
&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._15y.1,
]
}
}
impl<T> From<GroupedByUpToDate<T>> for GroupedByUpToDate<(GroupFilter, T)> {
fn from(value: GroupedByUpToDate<T>) -> Self {
Self {
_1d: (GroupFilter::To(1), value._1d),
_1w: (GroupFilter::To(7), value._1w),
_1m: (GroupFilter::To(30), value._1m),
_2m: (GroupFilter::To(2 * 30), value._2m),
_3m: (GroupFilter::To(3 * 30), value._3m),
_4m: (GroupFilter::To(4 * 30), value._4m),
_5m: (GroupFilter::To(5 * 30), value._5m),
_6m: (GroupFilter::To(6 * 30), value._6m),
_1y: (GroupFilter::To(365), value._1y),
_2y: (GroupFilter::To(2 * 365), value._2y),
_3y: (GroupFilter::To(3 * 365), value._3y),
_4y: (GroupFilter::To(4 * 365), value._4y),
_5y: (GroupFilter::To(5 * 365), value._5y),
_6y: (GroupFilter::To(6 * 365), value._6y),
_7y: (GroupFilter::To(7 * 365), value._7y),
_8y: (GroupFilter::To(8 * 365), value._8y),
_10y: (GroupFilter::To(10 * 365), value._10y),
_15y: (GroupFilter::To(15 * 365), value._15y),
}
}
}

80
crates/brk_core/src/groups/by_up_to_size.rs
View File

@@ -1,80 +0,0 @@
use crate::Sats;
use super::GroupFilter;
#[derive(Default, Clone)]
pub struct GroupedByUpToSize<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> GroupedByUpToSize<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 13] {
[
&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,
]
}
}
impl<T> GroupedByUpToSize<(GroupFilter, T)> {
pub fn vecs(&self) -> [&T; 13] {
[
&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,
]
}
}
impl<T> From<GroupedByUpToSize<T>> for GroupedByUpToSize<(GroupFilter, T)> {
fn from(value: GroupedByUpToSize<T>) -> Self {
Self {
_10sats: (GroupFilter::To(Sats::_10.into()), value._10sats),
_100sats: (GroupFilter::To(Sats::_100.into()), value._100sats),
_1k_sats: (GroupFilter::To(Sats::_1K.into()), value._1k_sats),
_10k_sats: (GroupFilter::To(Sats::_10K.into()), value._10k_sats),
_100k_sats: (GroupFilter::To(Sats::_100K.into()), value._100k_sats),
_1m_sats: (GroupFilter::To(Sats::_1M.into()), value._1m_sats),
_10m_sats: (GroupFilter::To(Sats::_10M.into()), value._10m_sats),
_1btc: (GroupFilter::To(Sats::_1BTC.into()), value._1btc),
_10btc: (GroupFilter::To(Sats::_10BTC.into()), value._10btc),
_100btc: (GroupFilter::To(Sats::_100BTC.into()), value._100btc),
_1k_btc: (GroupFilter::To(Sats::_1K_BTC.into()), value._1k_btc),
_10k_btc: (GroupFilter::To(Sats::_10K_BTC.into()), value._10k_btc),
_100k_btc: (GroupFilter::To(Sats::_100K_BTC.into()), value._100k_btc),
}
}
}

24
crates/brk_core/src/groups/filter.rs
View File

@@ -5,9 +5,9 @@ use crate::{HalvingEpoch, OutputType};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum GroupFilter {
All,
To(usize),
LowerThan(usize),
Range(Range<usize>),
From(usize),
GreaterOrEqual(usize),
Epoch(HalvingEpoch),
Type(OutputType),
}
@@ -16,8 +16,8 @@ impl GroupFilter {
pub fn contains(&self, value: usize) -> bool {
match self {
GroupFilter::All => true,
GroupFilter::To(to) => *to > value,
GroupFilter::From(from) => *from <= value,
GroupFilter::LowerThan(max) => *max > value,
GroupFilter::GreaterOrEqual(min) => *min <= value,
GroupFilter::Range(r) => r.contains(&value),
GroupFilter::Epoch(_) => false,
GroupFilter::Type(_) => false,
@@ -27,19 +27,19 @@ impl GroupFilter {
pub fn includes(&self, other: &GroupFilter) -> bool {
match self {
GroupFilter::All => true,
GroupFilter::To(to) => match other {
GroupFilter::LowerThan(max) => match other {
GroupFilter::All => false,
GroupFilter::To(to2) => to >= to2,
GroupFilter::Range(range) => range.end <= *to,
GroupFilter::From(_) => false,
GroupFilter::LowerThan(max2) => max >= max2,
GroupFilter::Range(range) => range.end <= *max,
GroupFilter::GreaterOrEqual(_) => false,
GroupFilter::Epoch(_) => false,
GroupFilter::Type(_) => false,
},
GroupFilter::From(from) => match other {
GroupFilter::GreaterOrEqual(min) => match other {
GroupFilter::All => false,
GroupFilter::To(_) => false,
GroupFilter::Range(range) => range.start >= *from,
GroupFilter::From(from2) => from <= from2,
GroupFilter::LowerThan(_) => false,
GroupFilter::Range(range) => range.start >= *min,
GroupFilter::GreaterOrEqual(min2) => min <= min2,
GroupFilter::Epoch(_) => false,
GroupFilter::Type(_) => false,
},

24
crates/brk_core/src/groups/mod.rs
View File

@@ -1,31 +1,31 @@
mod address;
mod by_address_type;
mod by_date_range;
mod by_age_range;
mod by_amount_range;
mod by_epoch;
mod by_from_date;
mod by_from_size;
mod by_size_range;
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 by_up_to_date;
mod by_up_to_size;
mod filter;
mod utxo;
pub use address::*;
pub use by_address_type::*;
pub use by_date_range::*;
pub use by_age_range::*;
pub use by_amount_range::*;
pub use by_epoch::*;
pub use by_from_date::*;
pub use by_from_size::*;
pub use by_size_range::*;
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 by_up_to_date::*;
pub use by_up_to_size::*;
pub use filter::*;
pub use utxo::*;

95
crates/brk_core/src/groups/utxo.rs
View File

@@ -1,57 +1,56 @@
use crate::{
GroupFilter, GroupedByDateRange, GroupedByEpoch, GroupedByFromDate, GroupedByFromSize,
GroupedBySizeRange, GroupedBySpendableType, GroupedByTerm, GroupedByUpToDate,
GroupedByUpToSize,
ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge, ByMinAge,
BySpendableType, ByTerm, GroupFilter,
};
#[derive(Default, Clone)]
pub struct UTXOGroups<T> {
pub all: T,
pub by_date_range: GroupedByDateRange<T>,
pub by_epoch: GroupedByEpoch<T>,
pub by_from_date: GroupedByFromDate<T>,
pub by_from_size: GroupedByFromSize<T>,
pub by_size_range: GroupedBySizeRange<T>,
pub by_term: GroupedByTerm<T>,
pub by_type: GroupedBySpendableType<T>,
pub by_up_to_date: GroupedByUpToDate<T>,
pub by_up_to_size: GroupedByUpToSize<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 as_mut_vecs(&mut self) -> Vec<&mut T> {
[&mut self.all]
.into_iter()
.chain(self.by_term.as_mut_vec())
.chain(self.by_up_to_date.as_mut_vec())
.chain(self.by_from_date.as_mut_vec())
.chain(self.by_from_size.as_mut_vec())
.chain(self.by_date_range.as_mut_vec())
.chain(self.by_epoch.as_mut_vec())
.chain(self.by_size_range.as_mut_vec())
.chain(self.by_up_to_size.as_mut_vec())
.chain(self.by_type.as_mut_vec())
.chain(self.term.as_mut_vec())
.chain(self.max_age.as_mut_vec())
.chain(self.min_age.as_mut_vec())
.chain(self.ge_amount.as_mut_vec())
.chain(self.age_range.as_mut_vec())
.chain(self.epoch.as_mut_vec())
.chain(self.amount_range.as_mut_vec())
.chain(self.lt_amount.as_mut_vec())
.chain(self._type.as_mut_vec())
.collect::<Vec<_>>()
}
pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> {
self.by_date_range
self.age_range
.as_mut_vec()
.into_iter()
.chain(self.by_epoch.as_mut_vec())
.chain(self.by_size_range.as_mut_vec())
.chain(self.by_type.as_mut_vec())
.chain(self.epoch.as_mut_vec())
.chain(self.amount_range.as_mut_vec())
.chain(self._type.as_mut_vec())
.collect::<Vec<_>>()
}
pub fn as_mut_overlapping_vecs(&mut self) -> Vec<&mut T> {
[&mut self.all]
.into_iter()
.chain(self.by_term.as_mut_vec())
.chain(self.by_up_to_date.as_mut_vec())
.chain(self.by_from_date.as_mut_vec())
.chain(self.by_up_to_size.as_mut_vec())
.chain(self.by_from_size.as_mut_vec())
.chain(self.term.as_mut_vec())
.chain(self.max_age.as_mut_vec())
.chain(self.min_age.as_mut_vec())
.chain(self.lt_amount.as_mut_vec())
.chain(self.ge_amount.as_mut_vec())
.collect::<Vec<_>>()
}
}
@@ -60,15 +59,15 @@ impl<T> UTXOGroups<(GroupFilter, T)> {
pub fn vecs(&self) -> Vec<&T> {
[&self.all.1]
.into_iter()
.chain(self.by_term.vecs())
.chain(self.by_up_to_date.vecs())
.chain(self.by_from_date.vecs())
.chain(self.by_date_range.vecs())
.chain(self.by_epoch.vecs())
.chain(self.by_size_range.vecs())
.chain(self.by_type.vecs())
.chain(self.by_up_to_size.vecs())
.chain(self.by_from_size.vecs())
.chain(self.term.vecs())
.chain(self.max_age.vecs())
.chain(self.min_age.vecs())
.chain(self.age_range.vecs())
.chain(self.epoch.vecs())
.chain(self.amount_range.vecs())
.chain(self._type.vecs())
.chain(self.lt_amount.vecs())
.chain(self.ge_amount.vecs())
.collect::<Vec<_>>()
}
}
@@ -77,15 +76,15 @@ impl<T> From<UTXOGroups<T>> for UTXOGroups<(GroupFilter, T)> {
fn from(value: UTXOGroups<T>) -> Self {
Self {
all: (GroupFilter::All, value.all),
by_term: GroupedByTerm::from(value.by_term),
by_up_to_date: GroupedByUpToDate::from(value.by_up_to_date),
by_from_date: GroupedByFromDate::from(value.by_from_date),
by_date_range: GroupedByDateRange::from(value.by_date_range),
by_epoch: GroupedByEpoch::from(value.by_epoch),
by_size_range: GroupedBySizeRange::from(value.by_size_range),
by_up_to_size: GroupedByUpToSize::from(value.by_up_to_size),
by_from_size: GroupedByFromSize::from(value.by_from_size),
by_type: GroupedBySpendableType::from(value.by_type),
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),
}
}
}