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
87
88
89
90
91
92
93
94
95

use brk_error::Result;
use brk_types::{Day1, DifficultyEntry, HashrateEntry, HashrateSummary, Height, TimePeriod};
use vecdb::{ReadableOptionVec, ReadableVec, VecIndex};

use super::epochs::iter_difficulty_epochs;
use crate::Query;

impl Query {
    pub fn hashrate(&self, time_period: Option<TimePeriod>) -> Result<HashrateSummary> {
        let indexer = self.indexer();
        let computer = self.computer();
        let current_height = self.height();

        // Get current difficulty
        let current_difficulty = *indexer
            .vecs
            .blocks
            .difficulty
            .collect_one(current_height)
            .unwrap();

        // Get current hashrate
        let current_day1 = computer
            .indexes
            .height
            .day1
            .collect_one(current_height)
            .unwrap();

        let current_hashrate = *computer
            .mining
            .hashrate
            .rate
            .base
            .day1
            .collect_one_flat(current_day1)
            .unwrap_or_default() as u128;

        // Calculate start height based on time period
        let end = current_height.to_usize();
        let start = match time_period {
            Some(tp) => end.saturating_sub(tp.block_count()),
            None => 0,
        };

        // Get hashrate entries using iterators for efficiency
        let start_day1 = computer
            .indexes
            .height
            .day1
            .collect_one(Height::from(start))
            .unwrap();
        let end_day1 = current_day1;

        // Sample at regular intervals to avoid too many data points
        let total_days = end_day1.to_usize().saturating_sub(start_day1.to_usize()) + 1;
        let step = (total_days / 200).max(1); // Max ~200 data points

        let hashrate_vec = &computer.mining.hashrate.rate.base.day1;
        let timestamp_vec = &computer.indexes.timestamp.day1;

        let mut hashrates = Vec::with_capacity(total_days / step + 1);
        let mut di = start_day1.to_usize();
        while di <= end_day1.to_usize() {
            let day1 = Day1::from(di);
            if let (Some(hr), Some(timestamp)) = (
                hashrate_vec.collect_one_flat(day1),
                timestamp_vec.collect_one(day1),
            ) {
                hashrates.push(HashrateEntry {
                    timestamp,
                    avg_hashrate: *hr as u128,
                });
            }
            di += step;
        }

        // Get difficulty adjustments within the period
        let difficulty: Vec<DifficultyEntry> = iter_difficulty_epochs(computer, start, end)
            .into_iter()
            .map(|e| DifficultyEntry {
                timestamp: e.timestamp,
                difficulty: e.difficulty,
                height: e.height,
            })
            .collect();

        Ok(HashrateSummary {
            hashrates,
            difficulty,
            current_hashrate,
            current_difficulty,
        })
    }
}