brk_computer 0.3.0-alpha.2

A Bitcoin dataset computer built on top of brk_indexer
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::path::Path;

use brk_error::Result;
use brk_types::{Age, Cents, FundedAddrData, Sats, SupplyState};
use vecdb::unlikely;

use super::super::cost_basis::{CostBasisRaw, RealizedOps};
use super::base::CohortState;

/// Significant digits for address cost basis prices (after rounding to dollars).
const COST_BASIS_PRICE_DIGITS: i32 = 4;

pub struct AddrCohortState<R: RealizedOps> {
    pub addr_count: u64,
    pub inner: CohortState<R, CostBasisRaw>,
}

impl<R: RealizedOps> AddrCohortState<R> {
    pub(crate) fn new(path: &Path, name: &str) -> Self {
        Self {
            addr_count: 0,
            inner: CohortState::new(path, name).with_price_rounding(COST_BASIS_PRICE_DIGITS),
        }
    }

    /// Reset state for fresh start.
    pub(crate) fn reset(&mut self) {
        self.addr_count = 0;
        self.inner.supply = SupplyState::default();
        self.inner.sent = Sats::ZERO;
        self.inner.spent_utxo_count = 0;
        self.inner.satdays_destroyed = Sats::ZERO;
        self.inner.realized = R::default();
    }

    pub(crate) fn send(
        &mut self,
        addr_data: &mut FundedAddrData,
        value: Sats,
        current_price: Cents,
        prev_price: Cents,
        ath: Cents,
        age: Age,
    ) -> Result<()> {
        let prev = addr_data.cost_basis_snapshot();
        addr_data.send(value, prev_price)?;
        let current = addr_data.cost_basis_snapshot();

        self.inner.send_addr(
            &SupplyState {
                utxo_count: 1,
                value,
            },
            current_price,
            prev_price,
            ath,
            age,
            &current,
            &prev,
        );

        Ok(())
    }

    pub(crate) fn receive_outputs(
        &mut self,
        addr_data: &mut FundedAddrData,
        value: Sats,
        price: Cents,
        output_count: u32,
    ) {
        let prev = addr_data.cost_basis_snapshot();
        addr_data.receive_outputs(value, price, output_count);
        let current = addr_data.cost_basis_snapshot();

        self.inner.receive_addr(
            &SupplyState {
                utxo_count: output_count as u64,
                value,
            },
            price,
            &current,
            &prev,
        );
    }

    pub(crate) fn add(&mut self, addr_data: &FundedAddrData) {
        self.addr_count += 1;
        self.inner
            .increment_snapshot(&addr_data.cost_basis_snapshot());
    }

    pub(crate) fn subtract(&mut self, addr_data: &FundedAddrData) {
        let snapshot = addr_data.cost_basis_snapshot();

        // Check for potential underflow before it happens
        if unlikely(self.inner.supply.utxo_count < snapshot.supply_state.utxo_count) {
            panic!(
                "AddrCohortState::subtract underflow!\n\
                Cohort state: addr_count={}, supply={}\n\
                Addr being subtracted: {}\n\
                Addr supply: {}\n\
                Realized price: {}\n\
                This means the addr is not properly tracked in this cohort.",
                self.addr_count,
                self.inner.supply,
                addr_data,
                snapshot.supply_state,
                snapshot.realized_price
            );
        }
        if unlikely(self.inner.supply.value < snapshot.supply_state.value) {
            panic!(
                "AddrCohortState::subtract value underflow!\n\
                Cohort state: addr_count={}, supply={}\n\
                Addr being subtracted: {}\n\
                Addr supply: {}\n\
                Realized price: {}\n\
                This means the addr is not properly tracked in this cohort.",
                self.addr_count,
                self.inner.supply,
                addr_data,
                snapshot.supply_state,
                snapshot.realized_price
            );
        }

        self.addr_count = self.addr_count.checked_sub(1).unwrap_or_else(|| {
            panic!(
                "AddrCohortState::subtract addr_count underflow! addr_count=0\n\
                Addr being subtracted: {}\n\
                Realized price: {}",
                addr_data, snapshot.realized_price
            )
        });

        self.inner.decrement_snapshot(&snapshot);
    }
}