brk_computer 0.11.1

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

mod cached_component_price;
mod components;
mod extremes;
mod inner;
mod percentiles;

use brk_error::Result;
use brk_indexer::Indexer;
use brk_traversable::Traversable;
use brk_types::Version;
use vecdb::{Database, Exit, Rw, StorageMode};

use crate::{
    distribution,
    frameworks::{coinflow, cointime},
    indexes, price,
};

pub use components::{Component, Components};
pub use extremes::Extremes;
pub use inner::RarityMeterInner;

#[derive(Traversable)]
pub struct RarityMeter<M: StorageMode = Rw> {
    pub components: Components<M>,
    pub extremes: Extremes<M>,
    pub full: RarityMeterInner<M>,
    pub local: RarityMeterInner<M>,
    pub cycle: RarityMeterInner<M>,
}

const VERSION: Version = Version::new(7);

impl RarityMeter {
    pub(crate) fn forced_import(
        db: &Database,
        version: Version,
        indexes: &indexes::Vecs,
        distribution: &distribution::Vecs,
        cointime: &cointime::Vecs,
        coinflow: &coinflow::Vecs,
    ) -> Result<Self> {
        let v = version + VERSION;
        Ok(Self {
            components: Components::forced_import(
                db,
                v,
                indexes,
                distribution,
                cointime,
                coinflow,
            )?,
            extremes: Extremes::forced_import(db, v, indexes)?,
            full: RarityMeterInner::forced_import(db, "rarity_meter", v, indexes)?,
            local: RarityMeterInner::forced_import(db, "local_rarity_meter", v, indexes)?,
            cycle: RarityMeterInner::forced_import(db, "cycle_rarity_meter", v, indexes)?,
        })
    }

    pub(crate) fn compute(
        &mut self,
        indexer: &Indexer,
        distribution: &distribution::Vecs,
        cointime: &cointime::Vecs,
        coinflow: &coinflow::Vecs,
        prices: &price::Vecs,
        exit: &Exit,
    ) -> Result<()> {
        let spot = &prices.spot.cents.height;
        let all = &distribution.utxo_cohorts.all.metrics;
        let realized = &all.realized;

        self.components
            .compute(indexer, distribution, cointime, coinflow, exit)?;
        self.extremes.compute(
            indexer,
            &all.supply.in_loss.btc.height,
            &realized.profit.sum._24h.usd.height,
            &realized.loss.sum._24h.usd.height,
            &realized.peak_regret.value.sum._24h.usd.height,
            &realized.sell_side_risk_ratio._24h.percent.height,
            exit,
        )?;

        // Full: all Rainbow components, 10 models
        self.full.compute(
            &[
                &self.components.under_4m_realized_price,
                &self.components.under_6m_realized_price,
                &self.components.over_4m_realized_price,
                &self.components.over_6m_realized_price,
                &self.components.sth_realized_price,
                &self.components.sth_capitalized_price,
                &self.components.lth_realized_price,
                &self.components.lth_capitalized_price,
                &self.components.realized_price,
                &self.components.capitalized_price,
            ],
            spot,
            indexer,
            exit,
        )?;

        // Local: young-coin and STH components, 4 models
        self.local.compute(
            &[
                &self.components.under_4m_realized_price,
                &self.components.under_6m_realized_price,
                &self.components.sth_realized_price,
                &self.components.sth_capitalized_price,
            ],
            spot,
            indexer,
            exit,
        )?;

        // Cycle: old-coin, all, and LTH components, 6 models
        self.cycle.compute(
            &[
                &self.components.over_4m_realized_price,
                &self.components.over_6m_realized_price,
                &self.components.realized_price,
                &self.components.capitalized_price,
                &self.components.lth_realized_price,
                &self.components.lth_capitalized_price,
            ],
            spot,
            indexer,
            exit,
        )?;

        Ok(())
    }
}