Struct BlockStore 

pub struct BlockStore {
    pub main: Tree,
    pub order: Tree,
    pub difficulty: Tree,
    pub state_inverse_diff: Tree,
}

The BlockStore is a structure representing all sled trees related to storing the blockchain’s blocks information.

Fields

main: Tree

Main sled tree, storing all the blockchain’s blocks, where the key is the blocks’ hash, and value is the serialized block.

order: Tree

The sled tree storing the order of the blockchain’s blocks, where the key is the height number, and the value is the blocks’ hash.

difficulty: Tree

The sled tree storing the difficulty information of the blockchain’s blocks, where the key is the block height number, and the value is the blocks’ hash.

state_inverse_diff: Tree

The sled tree storing each blocks’ full database state inverse changes, where the key is the block height number, and the value is the serialized database inverse diff.

Implementations

impl BlockStore

pub fn new(db: &Db) -> Result<Self>

Opens a new or existing BlockStore on the given sled database.

pub fn insert(&self, blocks: &[Block]) -> Result<Vec<HeaderHash>>

Insert a slice of Block into the store’s main tree.

pub fn insert_order(&self, heights: &[u32], hashes: &[HeaderHash]) -> Result<()>

Insert a slice of u32 and block hashes into the store’s order tree.

pub fn insert_difficulty( &self, block_difficulties: &[BlockDifficulty], ) -> Result<()>

Insert a slice of BlockDifficulty into the store’s difficulty tree.

pub fn insert_state_inverse_diff( &self, heights: &[u32], diffs: &[SledDbOverlayStateDiff], ) -> Result<()>

Insert a slice of u32 and block inverse diffs into the store’s database inverse diffs tree.

pub fn insert_batch(&self, blocks: &[Block]) -> (Batch, Vec<HeaderHash>)

Generate the sled batch corresponding to an insert to the main tree, so caller can handle the write operation. The block’s hash() function output is used as the key, while value is the serialized Block itself. On success, the function returns the block hashes in the same order.

pub fn insert_batch_order( &self, heights: &[u32], hashes: &[HeaderHash], ) -> Batch

Generate the sled batch corresponding to an insert to the order tree, so caller can handle the write operation. The block height is used as the key, and the block hash is used as value.

pub fn insert_batch_difficulty( &self, block_difficulties: &[BlockDifficulty], ) -> Batch

Generate the sled batch corresponding to an insert to the difficulty tree, so caller can handle the write operation. The block’s height number is used as the key, while value is

pub fn insert_batch_state_inverse_diff( &self, heights: &[u32], diffs: &[SledDbOverlayStateDiff], ) -> Batch

Generate the sled batch corresponding to an insert to the database inverse diffs tree, so caller can handle the write operation. The block height is used as the key, and the serialized database inverse diff is used as value.

pub fn contains(&self, blockhash: &HeaderHash) -> Result<bool>

Check if the store’s main tree contains a given block hash.

pub fn contains_order(&self, height: u32) -> Result<bool>

Check if the store’s order tree contains a given height.

pub fn get( &self, block_hashes: &[HeaderHash], strict: bool, ) -> Result<Vec<Option<Block>>>

Fetch given block hashes from the store’s main tree. The resulting vector contains Option, which is Some if the block was found in the block store, and otherwise it is None, if it has not. The second parameter is a boolean which tells the function to fail in case at least one block was not found.

pub fn get_order( &self, heights: &[u32], strict: bool, ) -> Result<Vec<Option<HeaderHash>>>

Fetch given heights from the store’s order tree. The resulting vector contains Option, which is Some if the height was found in the block order store, and otherwise it is None, if it has not. The second parameter is a boolean which tells the function to fail in case at least one height was not found.

pub fn get_difficulty( &self, heights: &[u32], strict: bool, ) -> Result<Vec<Option<BlockDifficulty>>>

Fetch given block height numbers from the store’s difficulty tree. The resulting vector contains Option, which is Some if the block height number was found in the block difficulties store, and otherwise it is None, if it has not. The second parameter is a boolean which tells the function to fail in case at least one block height number was not found.

pub fn get_state_inverse_diff( &self, heights: &[u32], strict: bool, ) -> Result<Vec<Option<SledDbOverlayStateDiff>>>

Fetch given block height numbers from the store’s state inverse diffs tree. The resulting vector contains Option, which is Some if the block height number was found in the block database inverse diffs store, and otherwise it is None, if it has not. The second parameter is a boolean which tells the function to fail in case at least one block height number was not found.

pub fn get_all(&self) -> Result<Vec<(HeaderHash, Block)>>

Retrieve all blocks from the store’s main tree in the form of a tuple (hash, block). Be careful as this will try to load everything in memory.

pub fn get_all_order(&self) -> Result<Vec<(u32, HeaderHash)>>

Retrieve complete order from the store’s order tree in the form of a vector containing (height, hash) tuples. Be careful as this will try to load everything in memory.

pub fn get_order_by_range( &self, start: u32, end: u32, ) -> Result<Vec<(u32, HeaderHash)>>

Fetches the blocks within a specified range of height from the store’s order tree returning a collection of block heights with their associated HeaderHashs.

pub fn get_all_difficulty(&self) -> Result<Vec<(u32, BlockDifficulty)>>

Retrieve all block difficulties from the store’s difficulty tree in the form of a vector containing (height, difficulty) tuples. Be careful as this will try to load everything in memory.

pub fn get_before(&self, height: u32, n: usize) -> Result<Vec<HeaderHash>>

Fetch n hashes before given height. In the iteration, if an order height is not found, the iteration stops and the function returns what it has found so far in the store’s order tree.

pub fn get_all_after(&self, height: u32) -> Result<Vec<HeaderHash>>

Fetch all hashes after given height. In the iteration, if an order height is not found, the iteration stops and the function returns what it has found so far in the store’s order tree.

pub fn get_first(&self) -> Result<(u32, HeaderHash)>

Fetch the first block hash in the order tree, based on the Ord implementation for Vec<u8>.

pub fn get_last(&self) -> Result<(u32, HeaderHash)>

Fetch the last block hash in the order tree, based on the Ord implementation for Vec<u8>.

pub fn get_last_n_orders(&self, n: usize) -> Result<Vec<(u32, HeaderHash)>>

Fetch the last N records from order tree

pub fn get_last_difficulty(&self) -> Result<Option<BlockDifficulty>>

Fetch the last record in the difficulty tree, based on the Ord implementation for Vec<u8>. If the tree is empty, returns None.

pub fn get_last_n_difficulties(&self, n: usize) -> Result<Vec<BlockDifficulty>>

Fetch the last N records from the store’s difficulty tree, in order.

pub fn get_difficulties_before( &self, height: u32, n: usize, ) -> Result<Vec<BlockDifficulty>>

Fetch N records before given height from the store’s difficulty tree, in order. In the iteration, if a record height is not found, the iteration stops and the function returns what it has found so far in the store’s difficulty tree.

pub fn get_state_inverse_diffs_after( &self, height: u32, ) -> Result<Vec<SledDbOverlayStateDiff>>

Fetch all state inverse diffs after given height. In the iteration, if a state inverse diff is not found, the iteration stops and the function returns what it has found so far in the store’s state inverse diffs tree.

pub fn len(&self) -> usize

Retrieve store’s order tree records count.

pub fn is_empty(&self) -> bool

Check if store’s order tree contains any records.

Trait Implementations

impl Clone for BlockStore

fn clone(&self) -> BlockStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.