Struct darkfi::blockchain::tx_store::TxStore

pub struct TxStore {
    pub main: Tree,
    pub location: Tree,
    pub pending: Tree,
    pub pending_order: Tree,
}

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

Fields

main: Tree

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

location: Tree

The sled tree storing the location of the blockchain’s transactions locations, where the key is the transaction hash, and the value is a serialized tuple containing the height and the vector index of the block the transaction is included.

pending: Tree

The sled tree storing all the node pending transactions, where the key is the transaction hash, and the value is the serialized transaction.

pending_order: Tree

The sled tree storing the order of all the node pending transactions, where the key is an incremental value, and the value is the serialized transaction.

Implementations

impl TxStore

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

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

pub fn insert( &self, transactions: &[Transaction], ) -> Result<Vec<TransactionHash>>

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

pub fn insert_location( &self, txs_hashes: &[TransactionHash], block_height: u32, ) -> Result<()>

Insert a slice of TransactionHash into the store’s location tree.

pub fn insert_pending( &self, transactions: &[Transaction], ) -> Result<Vec<TransactionHash>>

Insert a slice of Transaction into the store’s pending txs tree.

pub fn insert_pending_order(&self, txs_hashes: &[TransactionHash]) -> Result<()>

Insert a slice of TransactionHash into the store’s pending txs order tree.

pub fn insert_batch( &self, transactions: &[Transaction], ) -> (Batch, Vec<TransactionHash>)

Generate the sled batch corresponding to an insert to the main tree, so caller can handle the write operation. The transactions are hashed with BLAKE3 and this hash is used as the key, while the value is the serialized Transaction itself. On success, the function returns the transaction hashes in the same order as the input transactions, along with the corresponding operation batch.

pub fn insert_batch_location( &self, txs_hashes: &[TransactionHash], block_height: u32, ) -> Batch

Generate the sled batch corresponding to an insert to the location tree, so caller can handle the write operation. The location tuple is built using the index of each transaction has in the slice, along with the provided block height

pub fn insert_batch_pending( &self, transactions: &[Transaction], ) -> (Batch, Vec<TransactionHash>)

Generate the sled batch corresponding to an insert to the pending txs tree, so caller can handle the write operation. The transactions are hashed with BLAKE3 and this hash is used as the key, while the value is the serialized Transaction itself. On success, the function returns the transaction hashes in the same order as the input transactions, along with the corresponding operation batch.

pub fn insert_batch_pending_order( &self, tx_hashes: &[TransactionHash], ) -> Result<Batch>

Generate the sled batch corresponding to an insert to the pending txs order tree, so caller can handle the write operation.

pub fn contains(&self, tx_hash: &TransactionHash) -> Result<bool>

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

pub fn contains_pending(&self, tx_hash: &TransactionHash) -> Result<bool>

Check if the store’s pending txs tree contains a given transaction hash.

pub fn get( &self, tx_hashes: &[TransactionHash], strict: bool, ) -> Result<Vec<Option<Transaction>>>

Fetch given tx hashes from the store’s main tree. The resulting vector contains Option, which is Some if the tx was found in the txstore, 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 tx was not found.

pub fn get_location( &self, tx_hashes: &[TransactionHash], strict: bool, ) -> Result<Vec<Option<(u64, u16)>>>

Fetch given tx hashes locations from the store’s location tree. The resulting vector contains Option, which is Some if the tx was found in the txstore, 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 tx was not found.

pub fn get_pending( &self, tx_hashes: &[TransactionHash], strict: bool, ) -> Result<Vec<Option<Transaction>>>

Fetch given tx hashes from the store’s pending txs tree. The resulting vector contains Option, which is Some if the tx was found in the pending tx 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 tx was not found.

pub fn get_all(&self) -> Result<Vec<(TransactionHash, Transaction)>>

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

pub fn get_all_location(&self) -> Result<Vec<(TransactionHash, (u32, u16))>>

Retrieve all transactions locations from the store’s location tree in the form of a tuple (tx_hash, (block_height, index)). Be careful as this will try to load everything in memory.

pub fn get_all_pending(&self) -> Result<HashMap<TransactionHash, Transaction>>

Retrieve all transactions from the store’s pending txs tree in the form of a HashMap with key the transaction hash and value the transaction itself. Be careful as this will try to load everything in memory.

pub fn get_all_pending_order(&self) -> Result<Vec<(u64, TransactionHash)>>

Retrieve all transactions from the store’s pending txs order tree in the form of a tuple (u64, TransactionHash). Be careful as this will try to load everything in memory.

pub fn get_after_pending( &self, order: u64, n: usize, ) -> Result<(u64, Vec<Transaction>)>

Fetch n transactions after given order([order..order+n)). In the iteration, if a transaction order is not found, the iteration stops and the function returns what it has found so far in the store’s pending order tree.

pub fn len(&self) -> usize

Retrieve records count of the store’s main tree.

pub fn is_empty(&self) -> bool

Check if the store’s main tree is empty.

pub fn remove_pending(&self, txs_hashes: &[TransactionHash]) -> Result<()>

Remove a slice of TransactionHash from the store’s pending txs tree.

pub fn remove_pending_order(&self, indexes: &[u64]) -> Result<()>

Remove a slice of u64 from the store’s pending txs order tree.

pub fn remove_batch_pending(&self, txs_hashes: &[TransactionHash]) -> Batch

Generate the sled batch corresponding to a remove from the store’s pending txs tree, so caller can handle the write operation.

pub fn remove_batch_pending_order(&self, indexes: &[u64]) -> Batch

Generate the sled batch corresponding to a remove from the store’s pending txs order tree, so caller can handle the write operation.

Trait Implementations

impl Clone for TxStore

fn clone(&self) -> TxStore

Returns a copy of the value.

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

Performs copy-assignment from source.