brk_computer 0.11.0

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

use brk_error::Result;
use brk_types::{Cents, StoredF64, Version};

use super::Vecs;
use crate::{
    distribution::AllChainCache,
    indexes,
    internal::{Identity, LazyPerBlock},
    transactions,
};

impl Vecs {
    pub(crate) fn forced_import(
        version: Version,
        indexes: &indexes::Vecs,
        all_chain: &AllChainCache,
        transactions: &transactions::Vecs,
    ) -> Result<Self> {
        let volume = &transactions.volume.transfer_volume.sum._1y;
        let native_source = all_chain.with_supply(
            "velocity_btc_source",
            version,
            &volume.sats.height,
            |_, volume, supply| Self::ratio(f64::from(volume), f64::from(supply)),
        );
        let fiat_source = all_chain.with_market_cap(
            "velocity_usd_source",
            version,
            &volume.cents.height,
            |_, volume: Cents, market_cap| Self::ratio(f64::from(volume), f64::from(market_cap)),
        );

        Ok(Self {
            native: LazyPerBlock::from_uncached_height_source::<Identity<StoredF64>, _>(
                "velocity_btc",
                version,
                native_source,
                indexes,
            ),
            fiat: LazyPerBlock::from_uncached_height_source::<Identity<StoredF64>, _>(
                "velocity_usd",
                version,
                fiat_source,
                indexes,
            ),
        })
    }

    fn ratio(numerator: f64, denominator: f64) -> StoredF64 {
        if denominator != 0.0 {
            StoredF64::from(numerator / denominator)
        } else {
            StoredF64::from(0.0)
        }
    }
}