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
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

use brk_error::Result;
use brk_traversable::Traversable;
use brk_types::{Bitcoin, Indexes, StoredF64, Version};
use derive_more::{Deref, DerefMut};
use vecdb::{AnyStoredVec, AnyVec, Exit, Rw, StorageMode, WritableVec};

use crate::{
    distribution::{
        metrics::ImportConfig,
        state::{CohortState, CostBasisOps, RealizedOps},
    },
    internal::{AmountPerBlockCumulativeRolling, PerBlockCumulativeRolling},
    prices,
};

use super::ActivityMinimal;

#[derive(Deref, DerefMut, Traversable)]
pub struct ActivityCore<M: StorageMode = Rw> {
    #[deref]
    #[deref_mut]
    #[traversable(flatten)]
    pub minimal: ActivityMinimal<M>,

    pub coindays_destroyed: PerBlockCumulativeRolling<StoredF64, StoredF64, M>,
    #[traversable(wrap = "transfer_volume", rename = "in_profit")]
    pub transfer_volume_in_profit: AmountPerBlockCumulativeRolling<M>,
    #[traversable(wrap = "transfer_volume", rename = "in_loss")]
    pub transfer_volume_in_loss: AmountPerBlockCumulativeRolling<M>,
}

impl ActivityCore {
    pub(crate) fn forced_import(cfg: &ImportConfig) -> Result<Self> {
        let v1 = Version::ONE;
        Ok(Self {
            minimal: ActivityMinimal::forced_import(cfg)?,
            coindays_destroyed: cfg.import("coindays_destroyed", v1)?,
            transfer_volume_in_profit: cfg.import("transfer_volume_in_profit", v1)?,
            transfer_volume_in_loss: cfg.import("transfer_volume_in_loss", v1)?,
        })
    }

    pub(crate) fn min_len(&self) -> usize {
        self.minimal
            .min_len()
            .min(self.coindays_destroyed.block.len())
            .min(self.transfer_volume_in_profit.block.sats.len())
            .min(self.transfer_volume_in_loss.block.sats.len())
    }

    #[inline(always)]
    pub(crate) fn push_state(&mut self, state: &CohortState<impl RealizedOps, impl CostBasisOps>) {
        self.minimal.push_state(state);
        self.coindays_destroyed
            .block
            .push(StoredF64::from(Bitcoin::from(state.satdays_destroyed)));
        self.transfer_volume_in_profit
            .block
            .sats
            .push(state.realized.sent_in_profit());
        self.transfer_volume_in_loss
            .block
            .sats
            .push(state.realized.sent_in_loss());
    }

    pub(crate) fn collect_vecs_mut(&mut self) -> Vec<&mut dyn AnyStoredVec> {
        let mut vecs = self.minimal.collect_vecs_mut();
        vecs.push(&mut self.coindays_destroyed.block);
        vecs.push(&mut self.transfer_volume_in_profit.inner.block.sats);
        vecs.push(&mut self.transfer_volume_in_profit.inner.block.cents);
        vecs.push(&mut self.transfer_volume_in_loss.inner.block.sats);
        vecs.push(&mut self.transfer_volume_in_loss.inner.block.cents);
        vecs
    }

    pub(crate) fn validate_computed_versions(&mut self, _base_version: Version) -> Result<()> {
        Ok(())
    }

    pub(crate) fn compute_from_stateful(
        &mut self,
        starting_indexes: &Indexes,
        others: &[&Self],
        exit: &Exit,
    ) -> Result<()> {
        let minimal_refs: Vec<&ActivityMinimal> = others.iter().map(|o| &o.minimal).collect();
        self.minimal
            .compute_from_stateful(starting_indexes, &minimal_refs, exit)?;

        sum_others!(self, starting_indexes, others, exit; coindays_destroyed.block);
        sum_others!(self, starting_indexes, others, exit; transfer_volume_in_profit.block.sats);
        sum_others!(self, starting_indexes, others, exit; transfer_volume_in_loss.block.sats);

        Ok(())
    }

    pub(crate) fn compute_rest_part1(
        &mut self,
        prices: &prices::Vecs,
        starting_indexes: &Indexes,
        exit: &Exit,
    ) -> Result<()> {
        self.minimal
            .compute_rest_part1(prices, starting_indexes, exit)?;
        self.coindays_destroyed
            .compute_rest(starting_indexes.height, exit)?;
        self.transfer_volume_in_profit
            .compute_rest(starting_indexes.height, prices, exit)?;
        self.transfer_volume_in_loss
            .compute_rest(starting_indexes.height, prices, exit)?;
        Ok(())
    }
}