brk_query 0.2.5

An interface to find and format data from BRK
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 brk_error::Result;
use brk_types::{BlockRewardsEntry, Height, Sats, TimePeriod};
use vecdb::{ReadableVec, VecIndex};

use crate::Query;

impl Query {
    pub fn block_rewards(&self, time_period: TimePeriod) -> Result<Vec<BlockRewardsEntry>> {
        let computer = self.computer();
        let indexer = self.indexer();
        let current_height = self.height().to_usize();
        let start = current_height.saturating_sub(time_period.block_count());

        let coinbase_vec = &computer.mining.rewards.coinbase.block.sats;
        let timestamp_vec = &indexer.vecs.blocks.timestamp;

        match time_period {
            // Per-block, exact rewards
            TimePeriod::Day | TimePeriod::ThreeDays => {
                let rewards: Vec<Sats> = coinbase_vec.collect_range_at(start, current_height + 1);
                let timestamps: Vec<brk_types::Timestamp> =
                    timestamp_vec.collect_range_at(start, current_height + 1);

                Ok(rewards
                    .iter()
                    .zip(timestamps.iter())
                    .enumerate()
                    .map(|(i, (reward, ts))| BlockRewardsEntry {
                        avg_height: (start + i) as u32,
                        timestamp: **ts,
                        avg_rewards: **reward,
                    })
                    .collect())
            }
            // Daily averages, sampled to ~200 points
            _ => {
                let first_height_vec = &computer.indexes.day1.first_height;
                let day1_vec = &computer.indexes.height.day1;

                let start_di = day1_vec
                    .collect_one(Height::from(start))
                    .unwrap_or_default();
                let end_di = day1_vec
                    .collect_one(Height::from(current_height))
                    .unwrap_or_default();

                let total_days = end_di.to_usize().saturating_sub(start_di.to_usize()) + 1;
                let step = (total_days / 200).max(1);

                let mut entries = Vec::with_capacity(total_days / step + 1);
                let mut di = start_di.to_usize();

                while di <= end_di.to_usize() {
                    let day = brk_types::Day1::from(di);
                    let next_day = brk_types::Day1::from(di + 1);

                    if let Some(first_h) = first_height_vec.collect_one(day) {
                        let next_h = first_height_vec
                            .collect_one(next_day)
                            .unwrap_or(Height::from(current_height + 1));

                        let block_count = next_h.to_usize() - first_h.to_usize();
                        if block_count > 0 {
                            let sum =
                                coinbase_vec
                                    .fold_range(first_h, next_h, Sats::ZERO, |acc, v| acc + v);
                            let avg = *sum / block_count as u64;

                            if let Some(ts) = timestamp_vec.collect_one(first_h) {
                                entries.push(BlockRewardsEntry {
                                    avg_height: first_h.to_usize() as u32,
                                    timestamp: *ts,
                                    avg_rewards: avg,
                                });
                            }
                        }
                    }

                    di += step;
                }

                Ok(entries)
            }
        }
    }
}