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

global: wip

Browse Source
This commit is contained in:
nym21
2025-06-02 18:22:42 +02:00
parent 98a312701f
commit 93ee5e480b
54 changed files with 3914 additions and 1076 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_state/src/outputs/by_range.rs → crates/brk_state/src/outputs/by_date_range.rs
+34 -7
View File
@@ -1,7 +1,8 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByRange<T> {
pub struct OutputsByDateRange<T> {
pub start_to_1d: T,
pub _1d_to_1w: T,
pub _1w_to_1m: T,
pub _1m_to_3m: T,
@@ -14,11 +15,13 @@ pub struct OutputsByRange<T> {
pub _5y_to_7y: T,
pub _7y_to_10y: T,
pub _10y_to_15y: T,
pub _15y_to_end: T,
}
impl<T> From<OutputsByRange<T>> for OutputsByRange<(OutputFilter, T)> {
fn from(value: OutputsByRange<T>) -> Self {
impl<T> From<OutputsByDateRange<T>> for OutputsByDateRange<(OutputFilter, T)> {
fn from(value: OutputsByDateRange<T>) -> Self {
Self {
start_to_1d: (OutputFilter::To(1), value.start_to_1d),
_1d_to_1w: (OutputFilter::Range(1..7), value._1d_to_1w),
_1w_to_1m: (OutputFilter::Range(7..30), value._1w_to_1m),
_1m_to_3m: (OutputFilter::Range(30..3 * 30), value._1m_to_3m),
@@ -31,13 +34,34 @@ impl<T> From<OutputsByRange<T>> for OutputsByRange<(OutputFilter, T)> {
_5y_to_7y: (OutputFilter::Range(5 * 365..7 * 365), value._5y_to_7y),
_7y_to_10y: (OutputFilter::Range(7 * 365..10 * 365), value._7y_to_10y),
_10y_to_15y: (OutputFilter::Range(10 * 365..15 * 365), value._10y_to_15y),
_15y_to_end: (OutputFilter::From(15 * 365), value._15y_to_end),
}
}
}
impl<T> OutputsByRange<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 12] {
impl<T> OutputsByDateRange<T> {
pub fn as_vec(&mut self) -> [&T; 14] {
[
&self.start_to_1d,
&self._1d_to_1w,
&self._1w_to_1m,
&self._1m_to_3m,
&self._3m_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_7y,
&self._7y_to_10y,
&self._10y_to_15y,
&self._15y_to_end,
]
}
pub fn as_mut_vec(&mut self) -> [&mut T; 14] {
[
&mut self.start_to_1d,
&mut self._1d_to_1w,
&mut self._1w_to_1m,
&mut self._1m_to_3m,
@@ -50,13 +74,15 @@ impl<T> OutputsByRange<T> {
&mut self._5y_to_7y,
&mut self._7y_to_10y,
&mut self._10y_to_15y,
&mut self._15y_to_end,
]
}
}
impl<T> OutputsByRange<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 12] {
impl<T> OutputsByDateRange<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 14] {
[
&self.start_to_1d.1,
&self._1d_to_1w.1,
&self._1w_to_1m.1,
&self._1m_to_3m.1,
@@ -69,6 +95,7 @@ impl<T> OutputsByRange<(OutputFilter, T)> {
&self._5y_to_7y.1,
&self._7y_to_10y.1,
&self._10y_to_15y.1,
&self._15y_to_end.1,
]
}
}
crates/brk_state/src/outputs/by_from.rs → crates/brk_state/src/outputs/by_from_date.rs
+5 -5
View File
@@ -1,7 +1,7 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByFrom<T> {
pub struct OutputsByFromDate<T> {
pub _1d: T,
pub _1w: T,
pub _1m: T,
@@ -22,7 +22,7 @@ pub struct OutputsByFrom<T> {
pub _15y: T,
}
impl<T> OutputsByFrom<T> {
impl<T> OutputsByFromDate<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
[
&mut self._1d,
@@ -47,7 +47,7 @@ impl<T> OutputsByFrom<T> {
}
}
impl<T> OutputsByFrom<(OutputFilter, T)> {
impl<T> OutputsByFromDate<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 18] {
[
&self._1d.1,
@@ -72,8 +72,8 @@ impl<T> OutputsByFrom<(OutputFilter, T)> {
}
}
impl<T> From<OutputsByFrom<T>> for OutputsByFrom<(OutputFilter, T)> {
fn from(value: OutputsByFrom<T>) -> Self {
impl<T> From<OutputsByFromDate<T>> for OutputsByFromDate<(OutputFilter, T)> {
fn from(value: OutputsByFromDate<T>) -> Self {
Self {
_1d: (OutputFilter::From(1), value._1d),
_1w: (OutputFilter::From(7), value._1w),
crates/brk_state/src/outputs/by_from_size.rs
+50
View File
@@ -0,0 +1,50 @@
use brk_core::Sats;
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByFromSize<T> {
pub _1_000sats: T,
pub _1btc: T,
pub _10btc: T,
pub _100btc: T,
}
impl<T> OutputsByFromSize<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 4] {
[
&mut self._1_000sats,
&mut self._1btc,
&mut self._10btc,
&mut self._100btc,
]
}
}
impl<T> OutputsByFromSize<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 4] {
[
&self._1_000sats.1,
&self._1btc.1,
&self._10btc.1,
&self._100btc.1,
]
}
}
impl<T> From<OutputsByFromSize<T>> for OutputsByFromSize<(OutputFilter, T)> {
fn from(value: OutputsByFromSize<T>) -> Self {
Self {
_1_000sats: (OutputFilter::From(1_000), value._1_000sats),
_1btc: (OutputFilter::From(usize::from(Sats::ONE_BTC)), value._1btc),
_10btc: (
OutputFilter::From(usize::from(10 * Sats::ONE_BTC)),
value._10btc,
),
_100btc: (
OutputFilter::From(usize::from(100 * Sats::ONE_BTC)),
value._100btc,
),
}
}
}
crates/brk_state/src/outputs/by_size.rs → crates/brk_state/src/outputs/by_size_range.rs
+44 -48
View File
@@ -1,8 +1,8 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsBySize<T> {
pub _0sat: T,
pub struct OutputsBySizeRange<T> {
pub _0sats: T,
pub from_1sat_to_10sats: T,
pub from_10sats_to_100sats: T,
pub from_100sats_to_1_000sats: T,
@@ -19,94 +19,70 @@ pub struct OutputsBySize<T> {
pub from_100_000btc: T,
}
impl<T> From<OutputsBySize<T>> for OutputsBySize<(OutputFilter, T)> {
fn from(value: OutputsBySize<T>) -> Self {
impl<T> From<OutputsBySizeRange<T>> for OutputsBySizeRange<(OutputFilter, T)> {
fn from(value: OutputsBySizeRange<T>) -> Self {
#[allow(clippy::inconsistent_digit_grouping)]
Self {
_0sat: (
// OutputFilter::Zero,
OutputFilter::Size,
value._0sat,
),
from_1sat_to_10sats: (
// OutputFilter::Size(Sats::new(1)..Sats::new(10)),
OutputFilter::Size,
value.from_1sat_to_10sats,
),
from_10sats_to_100sats: (
// OutputFilter::Size(Sats::new(10)..Sats::new(100)),
OutputFilter::Size,
value.from_10sats_to_100sats,
),
_0sats: (OutputFilter::To(1), value._0sats),
from_1sat_to_10sats: (OutputFilter::Range(1..10), value.from_1sat_to_10sats),
from_10sats_to_100sats: (OutputFilter::Range(10..100), value.from_10sats_to_100sats),
from_100sats_to_1_000sats: (
// OutputFilter::Size(Sats::new(100)..Sats::new(1_000)),
OutputFilter::Size,
OutputFilter::Range(100..1_000),
value.from_100sats_to_1_000sats,
),
from_1_000sats_to_10_000sats: (
// OutputFilter::Size(Sats::new(1_000)..Sats::new(10_000)),
OutputFilter::Size,
OutputFilter::Range(1_000..10_000),
value.from_1_000sats_to_10_000sats,
),
from_10_000sats_to_100_000sats: (
// OutputFilter::Size(Sats::new(10_000)..Sats::new(100_000)),
OutputFilter::Size,
OutputFilter::Range(10_000..100_000),
value.from_10_000sats_to_100_000sats,
),
from_100_000sats_to_1_000_000sats: (
// OutputFilter::Size(Sats::new(100_000)..Sats::new(1_000_000)),
OutputFilter::Size,
OutputFilter::Range(100_000..1_000_000),
value.from_100_000sats_to_1_000_000sats,
),
from_1_000_000sats_to_10_000_000sats: (
// OutputFilter::Size(Sats::new(1_000_000)..Sats::new(10_000_000)),
OutputFilter::Size,
OutputFilter::Range(1_000_000..10_000_000),
value.from_1_000_000sats_to_10_000_000sats,
),
from_10_000_000sats_to_1btc: (
// OutputFilter::Size(Sats::new(10_000_000)..Sats::new(1_00_000_000)),
OutputFilter::Size,
OutputFilter::Range(10_000_000..1_00_000_000),
value.from_10_000_000sats_to_1btc,
),
from_1btc_to_10btc: (
// OutputFilter::Size(Sats::new(1_00_000_000)..Sats::new(10_00_000_000)),
OutputFilter::Size,
OutputFilter::Range(1_00_000_000..10_00_000_000),
value.from_1btc_to_10btc,
),
from_10btc_to_100btc: (
// OutputFilter::Size(Sats::new(10_00_000_000)..Sats::new(100_00_000_000)),
OutputFilter::Size,
OutputFilter::Range(10_00_000_000..100_00_000_000),
value.from_10btc_to_100btc,
),
from_100btc_to_1_000btc: (
// OutputFilter::Size(Sats::new(100_00_000_000)..Sats::new(1_000_00_000_000)),
OutputFilter::Size,
OutputFilter::Range(100_00_000_000..1_000_00_000_000),
value.from_100btc_to_1_000btc,
),
from_1_000btc_to_10_000btc: (
// OutputFilter::Size(Sats::new(1_000_00_000_000)..Sats::new(10_000_00_000_000)),
OutputFilter::Size,
OutputFilter::Range(1_000_00_000_000..10_000_00_000_000),
value.from_1_000btc_to_10_000btc,
),
from_10_000btc_to_100_000btc: (
// OutputFilter::Size(Sats::new(10_000_00_000_000)..Sats::new(100_000_00_000_000)),
OutputFilter::Size,
OutputFilter::Range(10_000_00_000_000..100_000_00_000_000),
value.from_10_000btc_to_100_000btc,
),
from_100_000btc: (
// OutputFilter::Size(Sats::new(100_000_00_000_000)..Sats::MAX),
OutputFilter::Size,
OutputFilter::From(100_000_00_000_000),
value.from_100_000btc,
),
}
}
}
impl<T> OutputsBySize<T> {
impl<T> OutputsBySizeRange<T> {
#[allow(clippy::inconsistent_digit_grouping)]
pub fn get_mut(&mut self, group: usize) -> &mut T {
if group == 0 {
&mut self._0sat
&mut self._0sats
} else if group == 1 {
&mut self.from_1sat_to_10sats
} else if group == 10 {
@@ -138,9 +114,29 @@ impl<T> OutputsBySize<T> {
}
}
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_mut_vec(&mut self) -> [&mut T; 15] {
[
&mut self._0sat,
&mut self._0sats,
&mut self.from_1sat_to_10sats,
&mut self.from_10sats_to_100sats,
&mut self.from_100sats_to_1_000sats,
@@ -159,10 +155,10 @@ impl<T> OutputsBySize<T> {
}
}
impl<T> OutputsBySize<(OutputFilter, T)> {
impl<T> OutputsBySizeRange<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 15] {
[
&self._0sat.1,
&self._0sats.1,
&self.from_1sat_to_10sats.1,
&self.from_10sats_to_100sats.1,
&self.from_100sats_to_1_000sats.1,
crates/brk_state/src/outputs/by_term.rs
+2 -2
View File
@@ -21,8 +21,8 @@ impl<T> OutputsByTerm<(OutputFilter, T)> {
impl<T> From<OutputsByTerm<T>> for OutputsByTerm<(OutputFilter, T)> {
fn from(value: OutputsByTerm<T>) -> Self {
Self {
long: (OutputFilter::From(155), value.long),
short: (OutputFilter::To(155), value.short),
long: (OutputFilter::From(150), value.long),
short: (OutputFilter::To(150), value.short),
}
}
}
crates/brk_state/src/outputs/by_up_to.rs → crates/brk_state/src/outputs/by_up_to_date.rs
+5 -5
View File
@@ -1,7 +1,7 @@
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByUpTo<T> {
pub struct OutputsByUpToDate<T> {
pub _1d: T,
pub _1w: T,
pub _1m: T,
@@ -22,7 +22,7 @@ pub struct OutputsByUpTo<T> {
pub _15y: T,
}
impl<T> OutputsByUpTo<T> {
impl<T> OutputsByUpToDate<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 18] {
[
&mut self._1d,
@@ -47,7 +47,7 @@ impl<T> OutputsByUpTo<T> {
}
}
impl<T> OutputsByUpTo<(OutputFilter, T)> {
impl<T> OutputsByUpToDate<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 18] {
[
&self._1d.1,
@@ -72,8 +72,8 @@ impl<T> OutputsByUpTo<(OutputFilter, T)> {
}
}
impl<T> From<OutputsByUpTo<T>> for OutputsByUpTo<(OutputFilter, T)> {
fn from(value: OutputsByUpTo<T>) -> Self {
impl<T> From<OutputsByUpToDate<T>> for OutputsByUpToDate<(OutputFilter, T)> {
fn from(value: OutputsByUpToDate<T>) -> Self {
Self {
_1d: (OutputFilter::To(1), value._1d),
_1w: (OutputFilter::To(7), value._1w),
crates/brk_state/src/outputs/by_up_to_size.rs
+54
View File
@@ -0,0 +1,54 @@
use brk_core::Sats;
use super::OutputFilter;
#[derive(Default, Clone)]
pub struct OutputsByUpToSize<T> {
pub _1_000sats: T,
pub _10_000sats: T,
pub _1btc: T,
pub _10btc: T,
pub _100btc: T,
}
impl<T> OutputsByUpToSize<T> {
pub fn as_mut_vec(&mut self) -> [&mut T; 5] {
[
&mut self._1_000sats,
&mut self._10_000sats,
&mut self._1btc,
&mut self._10btc,
&mut self._100btc,
]
}
}
impl<T> OutputsByUpToSize<(OutputFilter, T)> {
pub fn vecs(&self) -> [&T; 5] {
[
&self._1_000sats.1,
&self._10_000sats.1,
&self._1btc.1,
&self._10btc.1,
&self._100btc.1,
]
}
}
impl<T> From<OutputsByUpToSize<T>> for OutputsByUpToSize<(OutputFilter, T)> {
fn from(value: OutputsByUpToSize<T>) -> Self {
Self {
_1_000sats: (OutputFilter::To(1_000), value._1_000sats),
_10_000sats: (OutputFilter::To(10_000), value._10_000sats),
_1btc: (OutputFilter::To(usize::from(Sats::ONE_BTC)), value._1btc),
_10btc: (
OutputFilter::To(usize::from(10 * Sats::ONE_BTC)),
value._10btc,
),
_100btc: (
OutputFilter::To(usize::from(100 * Sats::ONE_BTC)),
value._100btc,
),
}
}
}
crates/brk_state/src/outputs/filter.rs
+38 -1
View File
@@ -8,7 +8,44 @@ pub enum OutputFilter {
To(usize),
Range(Range<usize>),
From(usize),
Size,
Epoch(HalvingEpoch),
Type(OutputType),
}
impl OutputFilter {
pub fn contains(&self, value: usize) -> bool {
match self {
OutputFilter::All => true,
OutputFilter::To(to) => *to > value,
OutputFilter::From(from) => *from <= value,
OutputFilter::Range(r) => r.contains(&value),
OutputFilter::Epoch(_) => false,
OutputFilter::Type(_) => false,
}
}
pub fn includes(&self, other: &OutputFilter) -> bool {
match self {
OutputFilter::All => true,
OutputFilter::To(to) => match other {
OutputFilter::All => false,
OutputFilter::To(to2) => to >= to2,
OutputFilter::Range(range) => range.end <= *to,
OutputFilter::From(_) => true,
OutputFilter::Epoch(_) => false,
OutputFilter::Type(_) => false,
},
OutputFilter::From(from) => match other {
OutputFilter::All => false,
OutputFilter::To(_) => false,
OutputFilter::Range(range) => range.start >= *from,
OutputFilter::From(from2) => from <= from2,
OutputFilter::Epoch(_) => false,
OutputFilter::Type(_) => false,
},
OutputFilter::Range(_) => false,
OutputFilter::Epoch(_) => false,
OutputFilter::Type(_) => false,
}
}
}
crates/brk_state/src/outputs/mod.rs
+66 -32
View File
@@ -1,53 +1,83 @@
mod by_date_range;
mod by_epoch;
mod by_from;
mod by_range;
mod by_size;
mod by_from_date;
mod by_from_size;
mod by_size_range;
mod by_spendable_type;
mod by_term;
mod by_type;
mod by_unspendable_type;
mod by_up_to;
mod by_up_to_date;
mod by_up_to_size;
// mod by_value;
mod filter;
pub use by_date_range::*;
pub use by_epoch::*;
pub use by_from::*;
pub use by_range::*;
pub use by_size::*;
pub use by_from_date::*;
pub use by_from_size::*;
pub use by_size_range::*;
pub use by_spendable_type::*;
pub use by_term::*;
pub use by_type::*;
pub use by_unspendable_type::*;
pub use by_up_to::*;
pub use by_up_to_date::*;
pub use by_up_to_size::*;
// pub use by_value::*;
pub use filter::*;
#[derive(Default, Clone)]
pub struct Outputs<T> {
pub all: T,
pub by_term: OutputsByTerm<T>,
pub by_up_to: OutputsByUpTo<T>,
pub by_from: OutputsByFrom<T>,
pub by_range: OutputsByRange<T>,
pub by_date_range: OutputsByDateRange<T>,
pub by_epoch: OutputsByEpoch<T>,
pub by_from_date: OutputsByFromDate<T>,
pub by_from_size: OutputsByFromSize<T>,
pub by_size_range: OutputsBySizeRange<T>,
pub by_term: OutputsByTerm<T>,
pub by_type: OutputsBySpendableType<T>,
pub by_size: OutputsBySize<T>,
// // Needs whole UTXO set, TODO later
// // pub by_value: OutputsByValue<T>,
pub by_up_to_date: OutputsByUpToDate<T>,
pub by_up_to_size: OutputsByUpToSize<T>,
// Needs whole UTXO set, TODO later
// pub by_value: OutputsByValue<T>,
}
impl<T> Outputs<T> {
pub fn as_mut_vec(&mut self) -> Vec<&mut 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.as_mut_vec())
.chain(self.by_from.as_mut_vec())
.chain(self.by_range.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.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.by_value.as_mut_vec())
// .chain(self.by_value.as_mut_vec())
.collect::<Vec<_>>()
}
pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> {
self.by_date_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.by_value.as_mut_vec())
.collect::<Vec<_>>()
}
pub fn as_mut_overlaping_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())
.collect::<Vec<_>>()
}
}
@@ -57,13 +87,15 @@ impl<T> Outputs<(OutputFilter, T)> {
[&self.all.1]
.into_iter()
.chain(self.by_term.vecs())
.chain(self.by_up_to.vecs())
.chain(self.by_from.vecs())
.chain(self.by_range.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.vecs())
// // .chain(self.by_value.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.by_value.vecs())
.collect::<Vec<_>>()
}
}
@@ -73,13 +105,15 @@ impl<T> From<Outputs<T>> for Outputs<(OutputFilter, T)> {
Self {
all: (OutputFilter::All, value.all),
by_term: OutputsByTerm::from(value.by_term),
by_up_to: OutputsByUpTo::from(value.by_up_to),
by_from: OutputsByFrom::from(value.by_from),
by_range: OutputsByRange::from(value.by_range),
by_up_to_date: OutputsByUpToDate::from(value.by_up_to_date),
by_from_date: OutputsByFromDate::from(value.by_from_date),
by_date_range: OutputsByDateRange::from(value.by_date_range),
by_epoch: OutputsByEpoch::from(value.by_epoch),
by_size: OutputsBySize::from(value.by_size),
// // Needs whole UTXO set, TODO later
// // by_value: OutputsByValue<T>,
by_size_range: OutputsBySizeRange::from(value.by_size_range),
by_up_to_size: OutputsByUpToSize::from(value.by_up_to_size),
by_from_size: OutputsByFromSize::from(value.by_from_size),
// Needs whole UTXO set, TODO later
// by_value: OutputsByValue<T>,
by_type: OutputsBySpendableType::from(value.by_type),
}
}
crates/brk_state/src/transacted.rs
+19 -18
View File
@@ -12,7 +12,7 @@ use super::{OutputsByType, SupplyState};
pub struct Transacted {
pub spendable_supply: SupplyState,
pub by_type: OutputsByType<SupplyState>,
pub by_size: BTreeMap<usize, SupplyState>,
pub by_size_group: BTreeMap<usize, SupplyState>,
}
impl Transacted {
@@ -32,35 +32,35 @@ impl Transacted {
// Need to be in sync with by_size !! but plenty fast (I think)
if _value == 0 {
*self.by_size.entry(0).or_default() += &supply;
*self.by_size_group.entry(0).or_default() += &supply;
} else if _value < 10 {
*self.by_size.entry(1).or_default() += &supply;
*self.by_size_group.entry(1).or_default() += &supply;
} else if _value < 100 {
*self.by_size.entry(10).or_default() += &supply;
*self.by_size_group.entry(10).or_default() += &supply;
} else if _value < 1_000 {
*self.by_size.entry(100).or_default() += &supply;
*self.by_size_group.entry(100).or_default() += &supply;
} else if _value < 10_000 {
*self.by_size.entry(1_000).or_default() += &supply;
*self.by_size_group.entry(1_000).or_default() += &supply;
} else if _value < 100_000 {
*self.by_size.entry(10_000).or_default() += &supply;
*self.by_size_group.entry(10_000).or_default() += &supply;
} else if _value < 1_000_000 {
*self.by_size.entry(100_000).or_default() += &supply;
*self.by_size_group.entry(100_000).or_default() += &supply;
} else if _value < 10_000_000 {
*self.by_size.entry(1_000_000).or_default() += &supply;
*self.by_size_group.entry(1_000_000).or_default() += &supply;
} else if _value < 1_00_000_000 {
*self.by_size.entry(10_000_000).or_default() += &supply;
*self.by_size_group.entry(10_000_000).or_default() += &supply;
} else if _value < 10_00_000_000 {
*self.by_size.entry(1_00_000_000).or_default() += &supply;
*self.by_size_group.entry(1_00_000_000).or_default() += &supply;
} else if _value < 100_00_000_000 {
*self.by_size.entry(10_00_000_000).or_default() += &supply;
*self.by_size_group.entry(10_00_000_000).or_default() += &supply;
} else if _value < 1_000_00_000_000 {
*self.by_size.entry(100_00_000_000).or_default() += &supply;
*self.by_size_group.entry(100_00_000_000).or_default() += &supply;
} else if _value < 10_000_00_000_000 {
*self.by_size.entry(1_000_00_000_000).or_default() += &supply;
*self.by_size_group.entry(1_000_00_000_000).or_default() += &supply;
} else if _value < 100_000_00_000_000 {
*self.by_size.entry(10_000_00_000_000).or_default() += &supply;
*self.by_size_group.entry(10_000_00_000_000).or_default() += &supply;
} else {
*self.by_size.entry(100_000_00_000_000).or_default() += &supply;
*self.by_size_group.entry(100_000_00_000_000).or_default() += &supply;
}
}
@@ -86,14 +86,15 @@ impl Add for Transacted {
Self {
spendable_supply: self.spendable_supply + rhs.spendable_supply,
by_type: self.by_type + rhs.by_type,
by_size: Self::merge_by_size(self.by_size, rhs.by_size),
by_size_group: Self::merge_by_size(self.by_size_group, rhs.by_size_group),
}
}
}
impl AddAssign for Transacted {
fn add_assign(&mut self, rhs: Self) {
self.by_size = Self::merge_by_size(mem::take(&mut self.by_size), rhs.by_size);
self.by_size_group =
Self::merge_by_size(mem::take(&mut self.by_size_group), rhs.by_size_group);
self.spendable_supply += &rhs.spendable_supply;
self.by_type += rhs.by_type;
}