brk_computer 0.2.5

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

use std::path::Path;

use brk_error::Result;
use brk_types::Version;

use crate::{
    cointime, distribution, indexes,
    internal::{
        CachedWindowStarts, LazyAmountPerBlock, LazyFiatPerBlock, LazyRollingDeltasFiatFromHeight,
        PercentPerBlock, RollingWindows,
        db_utils::{finalize_db, open_db},
    },
    supply::burned,
};

use super::Vecs;

const VERSION: Version = Version::ONE;

impl Vecs {
    pub(crate) fn forced_import(
        parent: &Path,
        parent_version: Version,
        indexes: &indexes::Vecs,
        distribution: &distribution::Vecs,
        cointime: &cointime::Vecs,
        cached_starts: &CachedWindowStarts,
    ) -> Result<Self> {
        let db = open_db(parent, super::DB_NAME, 1_000_000)?;

        let version = parent_version + VERSION;
        let supply_metrics = &distribution.utxo_cohorts.all.metrics.supply;

        let circulating =
            LazyAmountPerBlock::identity("circulating_supply", &supply_metrics.total, version);

        let burned = burned::Vecs::forced_import(&db, version, indexes)?;

        // Inflation rate
        let inflation_rate =
            PercentPerBlock::forced_import(&db, "inflation_rate", version + Version::ONE, indexes)?;

        // Velocity
        let velocity = super::velocity::Vecs::forced_import(&db, version, indexes)?;

        // Market cap - lazy fiat (cents + usd) from distribution supply
        let market_cap =
            LazyFiatPerBlock::from_computed("market_cap", version, &supply_metrics.total.cents);

        // Market cap delta (change + rate across 4 windows)
        let market_cap_delta = LazyRollingDeltasFiatFromHeight::new(
            "market_cap_delta",
            version + Version::new(3),
            &market_cap.cents.height,
            cached_starts,
            indexes,
        );

        let market_minus_realized_cap_growth_rate = RollingWindows::forced_import(
            &db,
            "market_minus_realized_cap_growth_rate",
            version + Version::TWO,
            indexes,
        )?;

        let hodled_or_lost = LazyAmountPerBlock::identity(
            "hodled_or_lost_supply",
            &cointime.supply.vaulted,
            version,
        );

        let this = Self {
            db,
            circulating,
            burned,
            inflation_rate,
            velocity,
            market_cap,
            market_cap_delta,
            market_minus_realized_cap_growth_rate,
            hodled_or_lost,
        };
        finalize_db(&this.db, &this)?;
        Ok(this)
    }
}