Struct floresta_chain::pruned_utreexo::chain_state::ChainState

pub struct ChainState<PersistedState: ChainStore> { /* private fields */ }

Implementations

impl<PersistedState: ChainStore> ChainState<PersistedState>

pub fn push_headers( &self, headers: Vec<BlockHeader>, height: u32 ) -> Result<(), BlockchainError>

Just adds headers to the chainstate, without validating them.

pub fn new( chainstore: PersistedState, network: Network, assume_valid: AssumeValidArg ) -> ChainState<PersistedState>

pub fn load_chain_state( chainstore: KvChainStore<'_>, network: Network, assume_valid: AssumeValidArg ) -> Result<ChainState<KvChainStore<'_>>, BlockchainError>

pub fn acc(&self) -> Stump

pub fn get_bip34_height(&self, block: &Block) -> Option<u32>

pub fn validate_block_no_acc( &self, block: &Block, height: u32, inputs: HashMap<OutPoint, TxOut> ) -> Result<(), BlockchainError>

Validates the block without checking whether the inputs are present in the UTXO set. This function contains the core validation logic.

The methods BlockchainInterface::validate_block and UpdatableChainstate::connect_block call this and additionally verify the inclusion proof (i.e., they perform full validation).

Trait Implementations

impl<PersistedState: ChainStore> BlockchainInterface for ChainState<PersistedState>

type Error = BlockchainError

fn get_params(&self) -> Params

fn get_fork_point(&self, block: BlockHash) -> Result<BlockHash, Self::Error>

fn update_acc( &self, acc: Stump, block: UtreexoBlock, height: u32, proof: Proof, del_hashes: Vec<Hash> ) -> Result<Stump, Self::Error>

fn get_chain_tips(&self) -> Result<Vec<BlockHash>, Self::Error>

fn validate_block( &self, block: &Block, proof: Proof, inputs: HashMap<OutPoint, TxOut>, del_hashes: Vec<Hash>, acc: Stump ) -> Result<(), Self::Error>

fn get_block_locator_for_tip( &self, tip: BlockHash ) -> Result<Vec<BlockHash>, BlockchainError>

Returns a block locator from a given tip

fn is_in_idb(&self) -> bool

Tells whether or not we are on ibd

fn get_block_height(&self, hash: &BlockHash) -> Result<Option<u32>, Self::Error>

Returns the height of a block, given it’s hash

fn get_block_hash(&self, height: u32) -> Result<BlockHash, Self::Error>

Returns the block with a given height in our current tip.

fn get_tx(&self, _txid: &Txid) -> Result<Option<Transaction>, Self::Error>

Returns a bitcoin Transaction given it’s txid.

fn get_height(&self) -> Result<u32, Self::Error>

Get the height of our best know chain.

fn broadcast(&self, tx: &Transaction) -> Result<(), Self::Error>

Broadcasts a transaction to the network.

fn estimate_fee(&self, target: usize) -> Result<f64, Self::Error>

Returns fee estimation for inclusion in target blocks.

fn get_block(&self, _hash: &BlockHash) -> Result<Block, Self::Error>

Returns a block with a given hash if any.

fn get_best_block(&self) -> Result<(u32, BlockHash), Self::Error>

Returns the best known block

fn get_block_header(&self, hash: &BlockHash) -> Result<Header, Self::Error>

Returns associated header for block with hash

fn subscribe(&self, tx: Arc<dyn BlockConsumer>)

Register for receiving notifications for some event. Right now it only works for new blocks, but may work with transactions in the future too. if a module performs some heavy-lifting on the block’s data, it should pass in a vector or a channel where data can be transfered to the atual worker, otherwise chainstate will be stuck for as long as you have work to do.

fn get_block_locator(&self) -> Result<Vec<BlockHash>, BlockchainError>

Returns a block locator

fn get_validation_index(&self) -> Result<u32, Self::Error>

Returns the last block we validated

fn is_coinbase_mature( &self, height: u32, block: BlockHash ) -> Result<bool, Self::Error>

Checks if a coinbase is mature

fn get_unbroadcasted(&self) -> Vec<Transaction>

Returns the list of unbroadcasted transactions.

impl<T: ChainStore> From<ChainStateBuilder<T>> for ChainState<T>

fn from(builder: ChainStateBuilder<T>) -> Self

Converts to this type from the input type.

impl<PersistedState: ChainStore> UpdatableChainstate for ChainState<PersistedState>

fn switch_chain(&self, new_tip: BlockHash) -> Result<(), BlockchainError>

fn mark_block_as_valid(&self, block: BlockHash) -> Result<(), BlockchainError>

Marks one block as being fully validated, this overrides a block that was explicitly marked as invalid.

fn mark_chain_as_assumed( &self, acc: Stump, assumed_hash: BlockHash ) -> Result<bool, BlockchainError>

Marks a chain as fully-valid

fn invalidate_block(&self, block: BlockHash) -> Result<(), BlockchainError>

Tells this blockchain to consider this block invalid, and not build on top of it

fn toggle_ibd(&self, is_ibd: bool)

Toggle ibd on/off

fn connect_block( &self, block: &Block, proof: Proof, inputs: HashMap<OutPoint, TxOut>, del_hashes: Vec<Hash> ) -> Result<u32, BlockchainError>

This is one of the most important methods for a ChainState, it gets a block and some utreexo data, validates this block and connects to our chain of blocks. This function is meant to be atomic and prone of running in parallel.

fn handle_transaction(&self) -> Result<(), BlockchainError>

Not used for now, but in a future blockchain with mempool, we can process transactions that are not in a block yet.

fn flush(&self) -> Result<(), BlockchainError>

Persists our data. Should be invoked periodically.

fn accept_header(&self, header: BlockHeader) -> Result<(), BlockchainError>

Accepts a new header to our chain. This method is called before connect_block, and makes some basic checks on a header and saves it on disk. We only accept a block as valid after calling connect_block.

fn get_root_hashes(&self) -> Vec<NodeHash>

Returns the root hashes of our utreexo forest

fn get_partial_chain( &self, initial_height: u32, final_height: u32, acc: Stump ) -> Result<PartialChainState, BlockchainError>

Returns a partial chainstate from a range of blocks.