Struct DifficultyCache

pub struct DifficultyCache {
    pub timestamps: VecDeque<u64>,
    pub cumulative_difficulties: VecDeque<u128>,
    pub last_accounted_height: usize,
    pub config: DifficultyCacheConfig,
}

This struct is able to calculate difficulties from blockchain information.

Fields

timestamps: VecDeque<u64>

The list of timestamps in the window.

cumulative_difficulties: VecDeque<u128>

The current cumulative difficulty of the chain.

last_accounted_height: usize

The last height we accounted for.

config: DifficultyCacheConfig

The config

Implementations

impl DifficultyCache

pub async fn init_from_chain_height<D: Database + Clone>( chain_height: usize, config: DifficultyCacheConfig, database: D, chain: Chain, ) -> Result<Self, ContextCacheError>

Initialize the difficulty cache from the specified chain height.

pub async fn pop_blocks_main_chain<D: Database + Clone>( &mut self, numb_blocks: usize, database: D, ) -> Result<(), ContextCacheError>

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 fn new_block( &mut self, height: usize, timestamp: u64, cumulative_difficulty: u128, )

Add a new block to the difficulty cache.

pub fn next_difficulty(&self, hf: HardFork) -> u128

Returns the required difficulty for the next block.

See: https://cuprate.github.io/monero-book/consensus_rules/blocks/difficulty.html#calculating-difficulty

pub fn next_difficulties( &self, blocks: Vec<(u64, HardFork)>, current_hf: HardFork, ) -> Vec<u128>

Returns the difficulties for multiple next blocks, using the provided timestamps and hard-forks when needed.

The first difficulty will be the same as the difficulty from DifficultyCache::next_difficulty after that the first timestamp and hf will be applied to the cache and the difficulty from that will be added to the list.

After all timestamps and hfs have been dealt with the cache will be returned back to its original state and the difficulties will be returned.

pub fn median_timestamp(&self, numb_blocks: usize) -> Option<u64>

Returns the median timestamp over the last numb_blocks, including the genesis block if the block height is low enough.

Will return None if there aren’t enough blocks.

pub fn cumulative_difficulty(&self) -> u128

Returns the cumulative difficulty of the chain.

pub fn top_block_timestamp(&self) -> Option<u64>

Returns the top block’s timestamp, returns None if the top block is the genesis block.

Trait Implementations

impl Clone for DifficultyCache

fn clone(&self) -> DifficultyCache

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DifficultyCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for DifficultyCache

fn eq(&self, other: &DifficultyCache) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for DifficultyCache

impl StructuralPartialEq for DifficultyCache

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 96 bytes