use super::{ChainParams, ChainWork, CompactTarget};
use crate::primitives::U256;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct HeaderLink {
pub height: u32,
pub time: u32,
pub bits: u32,
}
pub trait HeaderAncestry {
fn link_at(&self, height: u32) -> Option<HeaderLink>;
fn work_between(&self, first: u32, last: u32) -> Result<ChainWork, DifficultyError> {
chain_work_between(self, first, last)
}
}
impl HeaderAncestry for [HeaderLink] {
fn link_at(&self, height: u32) -> Option<HeaderLink> {
let first = self.first()?.height;
let link = *self.get(height.checked_sub(first)? as usize)?;
(link.height == height).then_some(link)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum DifficultyError {
#[error("the difficulty rule needs the header at height {height}")]
MissingAncestor {
height: u32,
},
#[error("no difficulty answer after a parent at height {prev_height}")]
ChainTooShort {
prev_height: u32,
},
#[error("the chain parameters have no difficulty adjustment interval")]
InvalidParams,
#[error("no work between heights {first} and {last}")]
ZeroWork {
first: u32,
last: u32,
},
}
fn min_difficulty_after(params: &ChainParams, prev: HeaderLink) -> i64 {
i64::from(prev.time).saturating_add(params.pow_target_spacing.saturating_mul(2))
}
fn get<C: HeaderAncestry + ?Sized>(chain: &C, height: u32) -> Result<HeaderLink, DifficultyError> {
chain
.link_at(height)
.ok_or(DifficultyError::MissingAncestor { height })
}
pub fn chain_work_between<C: HeaderAncestry + ?Sized>(
chain: &C,
first: u32,
last: u32,
) -> Result<ChainWork, DifficultyError> {
let mut sum = ChainWork::ZERO;
for height in first.saturating_add(1)..=last {
sum = sum.wrapping_add(ChainWork::from_bits(get(chain, height)?.bits));
}
Ok(sum)
}
pub fn median_time_past<C: HeaderAncestry + ?Sized>(
chain: &C,
height: u32,
) -> Result<i64, DifficultyError> {
let mut times = Vec::with_capacity(11);
for h in height.saturating_sub(10)..=height {
times.push(i64::from(get(chain, h)?.time));
}
times.sort_unstable();
Ok(times[times.len() / 2])
}
pub fn next_work_required<C: HeaderAncestry + ?Sized>(
params: &ChainParams,
chain: &C,
prev_height: u32,
new_time: u32,
) -> Result<u32, DifficultyError> {
let prev = get(chain, prev_height)?;
if params.no_retargeting {
return Ok(prev.bits);
}
if prev.height >= params.daa_height {
return next_cash_work_required(params, chain, prev_height, new_time);
}
next_eda_work_required(params, chain, prev, new_time)
}
fn next_eda_work_required<C: HeaderAncestry + ?Sized>(
params: &ChainParams,
chain: &C,
prev: HeaderLink,
new_time: u32,
) -> Result<u32, DifficultyError> {
let interval = params.difficulty_adjustment_interval();
if interval <= 0 {
return Err(DifficultyError::InvalidParams);
}
let height = i64::from(prev.height) + 1;
if height % interval == 0 {
let first = get(chain, (height - interval) as u32)?;
return Ok(calculate_next_work_required(
params,
prev,
i64::from(first.time),
));
}
let pow_limit_bits = params.pow_limit_bits();
if params.allow_min_difficulty_blocks {
if i64::from(new_time) > min_difficulty_after(params, prev) {
return Ok(pow_limit_bits);
}
let mut index = prev;
while index.height != 0
&& i64::from(index.height) % interval != 0
&& index.bits == pow_limit_bits
{
index = get(chain, index.height - 1)?;
}
return Ok(index.bits);
}
if prev.bits == pow_limit_bits {
return Ok(pow_limit_bits);
}
let six = prev
.height
.checked_sub(6)
.ok_or(DifficultyError::ChainTooShort {
prev_height: prev.height,
})?;
let mtp6 = median_time_past(chain, prev.height)? - median_time_past(chain, six)?;
if mtp6 < 12 * 3600 {
return Ok(prev.bits);
}
let mut pow = CompactTarget::from_bits(prev.bits).target;
pow = pow.wrapping_add(pow.shr(2));
if pow > params.pow_limit {
pow = params.pow_limit;
}
Ok(pow.to_compact())
}
pub fn calculate_next_work_required(
params: &ChainParams,
prev: HeaderLink,
first_block_time: i64,
) -> u32 {
if params.no_retargeting {
return prev.bits;
}
let timespan = params.pow_target_timespan;
let actual = (i64::from(prev.time) - first_block_time)
.max(timespan / 4)
.min(timespan.saturating_mul(4));
let mut target = CompactTarget::from_bits(prev.bits).target;
target = target.wrapping_mul_u64(u64::from(actual as u32));
target = target
.checked_div(U256::from_u64(timespan as u64))
.unwrap_or(U256::ZERO);
if target > params.pow_limit {
target = params.pow_limit;
}
target.to_compact()
}
fn suitable_block<C: HeaderAncestry + ?Sized>(
chain: &C,
height: u32,
) -> Result<HeaderLink, DifficultyError> {
let mut blocks = [
get(chain, height - 2)?,
get(chain, height - 1)?,
get(chain, height)?,
];
if blocks[0].time > blocks[2].time {
blocks.swap(0, 2);
}
if blocks[0].time > blocks[1].time {
blocks.swap(0, 1);
}
if blocks[1].time > blocks[2].time {
blocks.swap(1, 2);
}
Ok(blocks[1])
}
fn compute_target<C: HeaderAncestry + ?Sized>(
params: &ChainParams,
chain: &C,
first: HeaderLink,
last: HeaderLink,
) -> Result<U256, DifficultyError> {
let spacing = params.pow_target_spacing;
let mut work = *chain.work_between(first.height, last.height)?.as_u256();
work = work.wrapping_mul_u64(u64::from(spacing as u32));
let actual = (i64::from(last.time) - i64::from(first.time))
.min(spacing.saturating_mul(288))
.max(spacing.saturating_mul(72));
work = work
.checked_div(U256::from_u64(actual as u64))
.unwrap_or(U256::ZERO);
work.wrapping_neg()
.checked_div(work)
.ok_or(DifficultyError::ZeroWork {
first: first.height,
last: last.height,
})
}
pub fn next_cash_work_required<C: HeaderAncestry + ?Sized>(
params: &ChainParams,
chain: &C,
prev_height: u32,
new_time: u32,
) -> Result<u32, DifficultyError> {
let prev = get(chain, prev_height)?;
if params.allow_min_difficulty_blocks
&& i64::from(new_time) > min_difficulty_after(params, prev)
{
return Ok(params.pow_limit_bits());
}
let interval = params.difficulty_adjustment_interval();
if interval <= 0 {
return Err(DifficultyError::InvalidParams);
}
if i64::from(prev_height) < interval.max(147) {
return Err(DifficultyError::ChainTooShort { prev_height });
}
let last = suitable_block(chain, prev_height)?;
let first = suitable_block(chain, prev_height - 144)?;
let target = compute_target(params, chain, first, last)?;
if target > params.pow_limit {
return Ok(params.pow_limit_bits());
}
Ok(target.to_compact())
}