cuprate_consensus_context/
hardforks.rsuse 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};
const DEFAULT_WINDOW_SIZE: usize = 10080; #[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct HardForkConfig {
pub info: HFsInfo,
pub window: usize,
}
impl HardForkConfig {
pub const fn main_net() -> Self {
Self {
info: HFsInfo::main_net(),
window: DEFAULT_WINDOW_SIZE,
}
}
pub const fn stage_net() -> Self {
Self {
info: HFsInfo::stage_net(),
window: DEFAULT_WINDOW_SIZE,
}
}
pub const fn test_net() -> Self {
Self {
info: HFsInfo::test_net(),
window: DEFAULT_WINDOW_SIZE,
}
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct HardForkState {
pub current_hardfork: HardFork,
pub config: HardForkConfig,
pub votes: HFVotes,
pub last_height: usize,
}
impl HardForkState {
#[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)
}
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(())
}
pub fn new_block(&mut self, vote: HardFork, height: usize) {
assert_eq!(self.last_height + 1, height);
self.last_height += 1;
tracing::debug!(
"Accounting for new blocks vote, height: {}, vote: {:?}",
self.last_height,
vote
);
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();
}
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,
);
}
pub const fn current_hardfork(&self) -> HardFork {
self.current_hardfork
}
}
#[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)
}