brk_state 0.0.71

Various states used in the Bitcoin Research Kit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use std::{
    collections::BTreeMap,
    mem,
    ops::{Add, AddAssign},
};

use brk_core::{OutputType, Sats};

use super::{OutputsByType, SupplyState};

#[derive(Default, Debug)]
pub struct Transacted {
    pub spendable_supply: SupplyState,
    pub by_type: OutputsByType<SupplyState>,
    pub by_size_group: BTreeMap<usize, SupplyState>,
}

impl Transacted {
    #[allow(clippy::inconsistent_digit_grouping)]
    pub fn iterate(&mut self, value: Sats, _type: OutputType) {
        let supply = SupplyState { utxos: 1, value };

        *self.by_type.get_mut(_type) += &supply;

        if _type.is_unspendable() {
            return;
        }

        self.spendable_supply += &supply;

        let _value = usize::from(value);

        // Need to be in sync with by_size !! but plenty fast (I think)
        if _value == 0 {
            *self.by_size_group.entry(0).or_default() += &supply;
        } else if _value < 10 {
            *self.by_size_group.entry(1).or_default() += &supply;
        } else if _value < 100 {
            *self.by_size_group.entry(10).or_default() += &supply;
        } else if _value < 1_000 {
            *self.by_size_group.entry(100).or_default() += &supply;
        } else if _value < 10_000 {
            *self.by_size_group.entry(1_000).or_default() += &supply;
        } else if _value < 100_000 {
            *self.by_size_group.entry(10_000).or_default() += &supply;
        } else if _value < 1_000_000 {
            *self.by_size_group.entry(100_000).or_default() += &supply;
        } else if _value < 10_000_000 {
            *self.by_size_group.entry(1_000_000).or_default() += &supply;
        } else if _value < 1_00_000_000 {
            *self.by_size_group.entry(10_000_000).or_default() += &supply;
        } else if _value < 10_00_000_000 {
            *self.by_size_group.entry(1_00_000_000).or_default() += &supply;
        } else if _value < 100_00_000_000 {
            *self.by_size_group.entry(10_00_000_000).or_default() += &supply;
        } else if _value < 1_000_00_000_000 {
            *self.by_size_group.entry(100_00_000_000).or_default() += &supply;
        } else if _value < 10_000_00_000_000 {
            *self.by_size_group.entry(1_000_00_000_000).or_default() += &supply;
        } else if _value < 100_000_00_000_000 {
            *self.by_size_group.entry(10_000_00_000_000).or_default() += &supply;
        } else {
            *self.by_size_group.entry(100_000_00_000_000).or_default() += &supply;
        }
    }

    fn merge_by_size(
        first: BTreeMap<usize, SupplyState>,
        second: BTreeMap<usize, SupplyState>,
    ) -> BTreeMap<usize, SupplyState> {
        let (mut source, to_consume) = if first.len() > second.len() {
            (first, second)
        } else {
            (second, first)
        };
        to_consume.into_iter().for_each(|(k, v)| {
            *source.entry(k).or_default() += &v;
        });
        source
    }
}

impl Add for Transacted {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        Self {
            spendable_supply: self.spendable_supply + rhs.spendable_supply,
            by_type: self.by_type + rhs.by_type,
            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_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;
    }
}