cuprate_consensus_context/
hardforks.rs

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
use std::ops::Range;

use tower::ServiceExt;
use tracing::instrument;

use cuprate_consensus_rules::{HFVotes, HFsInfo, HardFork};
use cuprate_types::{
    blockchain::{BlockchainReadRequest, BlockchainResponse},
    Chain,
};

use crate::{ContextCacheError, Database};

/// The default amount of hard-fork votes to track to decide on activation of a hard-fork.
///
/// ref: <https://cuprate.github.io/monero-docs/consensus_rules/hardforks.html#accepting-a-fork>
const DEFAULT_WINDOW_SIZE: usize = 10080; // supermajority window check length - a week

/// Configuration for hard-forks.
///
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct HardForkConfig {
    /// The network we are on.
    pub info: HFsInfo,
    /// The amount of votes we are taking into account to decide on a fork activation.
    pub window: usize,
}

impl HardForkConfig {
    /// Config for main-net.
    pub const fn main_net() -> Self {
        Self {
            info: HFsInfo::main_net(),
            window: DEFAULT_WINDOW_SIZE,
        }
    }

    /// Config for stage-net.
    pub const fn stage_net() -> Self {
        Self {
            info: HFsInfo::stage_net(),
            window: DEFAULT_WINDOW_SIZE,
        }
    }

    /// Config for test-net.
    pub const fn test_net() -> Self {
        Self {
            info: HFsInfo::test_net(),
            window: DEFAULT_WINDOW_SIZE,
        }
    }
}

/// A struct that keeps track of the current hard-fork and current votes.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct HardForkState {
    /// The current active hard-fork.
    pub current_hardfork: HardFork,

    /// The hard-fork config.
    pub config: HardForkConfig,
    /// The votes in the current window.
    pub votes: HFVotes,

    /// The last block height accounted for.
    pub last_height: usize,
}

impl HardForkState {
    /// Initialize the [`HardForkState`] from the specified chain height.
    #[instrument(name = "init_hardfork_state", skip(config, database), level = "info")]
    pub async fn init_from_chain_height<D: Database + Clone>(
        chain_height: usize,
        config: HardForkConfig,
        mut database: D,
    ) -> Result<Self, ContextCacheError> {
        tracing::info!("Initializing hard-fork state this may take a while.");

        let block_start = chain_height.saturating_sub(config.window);

        let votes =
            get_votes_in_range(database.clone(), block_start..chain_height, config.window).await?;

        if chain_height > config.window {
            debug_assert_eq!(votes.total_votes(), config.window);
        }

        let BlockchainResponse::BlockExtendedHeader(ext_header) = database
            .ready()
            .await?
            .call(BlockchainReadRequest::BlockExtendedHeader(chain_height - 1))
            .await?
        else {
            panic!("Database sent incorrect response!");
        };

        let current_hardfork = ext_header.version;

        let mut hfs = Self {
            config,
            current_hardfork,
            votes,
            last_height: chain_height - 1,
        };

        hfs.check_set_new_hf();

        tracing::info!(
            "Initialized Hfs, current fork: {:?}, {}",
            hfs.current_hardfork,
            hfs.votes
        );

        Ok(hfs)
    }

    /// Pop some blocks from the top of the cache.
    ///
    /// The cache will be returned to the state it would have been in `numb_blocks` ago.
    ///
    /// # Invariant
    ///
    /// This _must_ only be used on a main-chain cache.
    pub async fn pop_blocks_main_chain<D: Database + Clone>(
        &mut self,
        numb_blocks: usize,
        database: D,
    ) -> Result<(), ContextCacheError> {
        let Some(retained_blocks) = self.votes.total_votes().checked_sub(self.config.window) else {
            *self = Self::init_from_chain_height(
                self.last_height + 1 - numb_blocks,
                self.config,
                database,
            )
            .await?;

            return Ok(());
        };

        let current_chain_height = self.last_height + 1;

        let oldest_votes = get_votes_in_range(
            database,
            current_chain_height
                .saturating_sub(self.config.window)
                .saturating_sub(numb_blocks)
                ..current_chain_height
                    .saturating_sub(numb_blocks)
                    .saturating_sub(retained_blocks),
            numb_blocks,
        )
        .await?;

        self.votes.reverse_blocks(numb_blocks, oldest_votes);
        self.last_height -= numb_blocks;

        Ok(())
    }

    /// Add a new block to the cache.
    pub fn new_block(&mut self, vote: HardFork, height: usize) {
        // We don't _need_ to take in `height` but it's for safety, so we don't silently loose track
        // of blocks.
        assert_eq!(self.last_height + 1, height);
        self.last_height += 1;

        tracing::debug!(
            "Accounting for new blocks vote, height: {}, vote: {:?}",
            self.last_height,
            vote
        );

        // This function remove votes outside the window as well.
        self.votes.add_vote_for_hf(&vote);

        if height > self.config.window {
            debug_assert_eq!(self.votes.total_votes(), self.config.window);
        }

        self.check_set_new_hf();
    }

    /// Checks if the next hard-fork should be activated and activates it if it should.
    ///
    /// <https://cuprate.github.io/monero-docs/consensus_rules/hardforks.html#accepting-a-fork>
    fn check_set_new_hf(&mut self) {
        self.current_hardfork = self.votes.current_fork(
            &self.current_hardfork,
            self.last_height + 1,
            self.config.window,
            &self.config.info,
        );
    }

    /// Returns the current hard-fork.
    pub const fn current_hardfork(&self) -> HardFork {
        self.current_hardfork
    }
}

/// Returns the block votes for blocks in the specified range.
#[instrument(name = "get_votes", skip(database))]
async fn get_votes_in_range<D: Database>(
    database: D,
    block_heights: Range<usize>,
    window_size: usize,
) -> Result<HFVotes, ContextCacheError> {
    let mut votes = HFVotes::new(window_size);

    let BlockchainResponse::BlockExtendedHeaderInRange(vote_list) = database
        .oneshot(BlockchainReadRequest::BlockExtendedHeaderInRange(
            block_heights,
            Chain::Main,
        ))
        .await?
    else {
        panic!("Database sent incorrect response!");
    };

    for hf_info in vote_list {
        votes.add_vote_for_hf(&HardFork::from_vote(hf_info.vote));
    }

    Ok(votes)
}