brk_types 0.3.0-alpha.6

Structs used throughout 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
96
97
98
99
100
101
102

use std::borrow::Cow;

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use crate::{Pool, PoolSlug, Sats};

/// Detailed pool information with statistics across time periods
#[derive(Debug, Serialize, Deserialize, JsonSchema)]
pub struct PoolDetail {
    /// Pool information
    pub pool: PoolDetailInfo,

    /// Block counts for different time periods
    #[serde(rename = "blockCount")]
    pub block_count: PoolBlockCounts,

    /// Pool's share of total blocks for different time periods
    #[serde(rename = "blockShare")]
    pub block_share: PoolBlockShares,

    /// Estimated hashrate based on blocks mined
    #[serde(rename = "estimatedHashrate")]
    pub estimated_hashrate: u128,

    /// Self-reported hashrate (if available)
    #[serde(rename = "reportedHashrate")]
    pub reported_hashrate: Option<u128>,

    /// Total reward earned by this pool (sats, all time; None for minor pools)
    #[serde(rename = "totalReward")]
    pub total_reward: Option<Sats>,
}

/// Pool information for detail view
#[derive(Debug, Serialize, Deserialize, JsonSchema)]
pub struct PoolDetailInfo {
    /// Pool identifier
    pub id: u8,

    /// Pool name
    pub name: Cow<'static, str>,

    /// Pool website URL
    pub link: Cow<'static, str>,

    /// Known payout addresses
    pub addresses: Vec<Cow<'static, str>>,

    /// Coinbase tag patterns (regexes)
    pub regexes: Vec<Cow<'static, str>>,

    /// URL-friendly pool identifier
    pub slug: PoolSlug,

    /// Unique pool identifier
    pub unique_id: u8,
}

impl From<&'static Pool> for PoolDetailInfo {
    fn from(pool: &'static Pool) -> Self {
        Self {
            id: pool.mempool_id(),
            name: Cow::Borrowed(pool.name),
            link: Cow::Borrowed(pool.link),
            addresses: pool.addrs.iter().map(|&s| Cow::Borrowed(s)).collect(),
            regexes: pool.tags.iter().map(|&s| Cow::Borrowed(s)).collect(),
            slug: pool.slug(),
            unique_id: pool.mempool_unique_id(),
        }
    }
}

/// Block counts for different time periods
#[derive(Debug, Serialize, Deserialize, JsonSchema)]
pub struct PoolBlockCounts {
    /// Total blocks mined (all time)
    pub all: u64,

    /// Blocks mined in last 24 hours
    #[serde(rename = "24h")]
    pub day: u64,

    /// Blocks mined in last week
    #[serde(rename = "1w")]
    pub week: u64,
}

/// Pool's share of total blocks for different time periods
#[derive(Debug, Serialize, Deserialize, JsonSchema)]
pub struct PoolBlockShares {
    /// Share of all blocks (0.0 - 1.0)
    pub all: f64,

    /// Share of blocks in last 24 hours
    #[serde(rename = "24h")]
    pub day: f64,

    /// Share of blocks in last week
    #[serde(rename = "1w")]
    pub week: f64,
}