darkfi/src/blockchain/mod.rs

/* This file is part of DarkFi (https://dark.fi)
 *
 * Copyright (C) 2020-2026 Dyne.org foundation
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

use std::{
    slice,
    sync::{Arc, Mutex},
};

use darkfi_sdk::tx::TransactionHash;
use darkfi_serial::{deserialize, Decodable};
use sled_overlay::{
    sled,
    sled::{IVec, Transactional},
};
use tracing::debug;

#[cfg(feature = "async-serial")]
use darkfi_serial::{deserialize_async, AsyncDecodable};

use crate::{tx::Transaction, util::time::Timestamp, Error, Result};

/// Block related definitions and storage implementations
pub mod block_store;
pub use block_store::{
    Block, BlockDifficulty, BlockInfo, BlockStore, BlockStoreOverlay, SLED_BLOCK_DIFFICULTY_TREE,
    SLED_BLOCK_ORDER_TREE, SLED_BLOCK_STATE_INVERSE_DIFF_TREE, SLED_BLOCK_TREE,
};

/// Header definition and storage implementation
pub mod header_store;
pub use header_store::{
    Header, HeaderHash, HeaderStore, HeaderStoreOverlay, SLED_HEADER_TREE, SLED_SYNC_HEADER_TREE,
};

/// Transactions related storage implementations
pub mod tx_store;
pub use tx_store::{
    TxStore, TxStoreOverlay, SLED_PENDING_TX_ORDER_TREE, SLED_PENDING_TX_TREE,
    SLED_TX_LOCATION_TREE, SLED_TX_TREE,
};

/// Contracts and Wasm storage implementations
pub mod contract_store;
pub use contract_store::{
    ContractStore, ContractStoreOverlay, SLED_BINCODE_TREE, SLED_CONTRACTS_TREE,
    SLED_CONTRACTS_TREES_TREE,
};

/// Monero definitions needed for merge mining
pub mod monero;

/// Structure holding all sled trees that define the concept of Blockchain.
#[derive(Clone)]
pub struct Blockchain {
    /// Main pointer to the sled db connection
    pub sled_db: sled::Db,
    /// Headers sled tree
    pub headers: HeaderStore,
    /// Blocks sled tree
    pub blocks: BlockStore,
    /// Transactions related sled trees
    pub transactions: TxStore,
    /// Contracts related sled trees
    pub contracts: ContractStore,
}

impl Blockchain {
    /// Instantiate a new `Blockchain` with the given `sled` database.
    pub fn new(db: &sled::Db) -> Result<Self> {
        let headers = HeaderStore::new(db)?;
        let blocks = BlockStore::new(db)?;
        let transactions = TxStore::new(db)?;
        let contracts = ContractStore::new(db)?;

        Ok(Self { sled_db: db.clone(), headers, blocks, transactions, contracts })
    }

    /// Insert a given [`BlockInfo`] into the blockchain database.
    /// This functions wraps all the logic of separating the block into specific
    /// data that can be fed into the different trees of the database.
    /// Upon success, the functions returns the block hash that
    /// were given and appended to the ledger.
    pub fn add_block(&self, block: &BlockInfo) -> Result<HeaderHash> {
        let mut trees = vec![];
        let mut batches = vec![];

        // Store header
        let (headers_batch, _) = self.headers.insert_batch(slice::from_ref(&block.header));
        trees.push(self.headers.main.clone());
        batches.push(headers_batch);

        // Store block
        let blk: Block = Block::from_block_info(block);
        let (bocks_batch, block_hashes) = self.blocks.insert_batch(&[blk]);
        let block_hash = block_hashes[0];
        let block_hash_vec = [block_hash];
        trees.push(self.blocks.main.clone());
        batches.push(bocks_batch);

        // Store block order
        let blocks_order_batch =
            self.blocks.insert_batch_order(&[block.header.height], &block_hash_vec);
        trees.push(self.blocks.order.clone());
        batches.push(blocks_order_batch);

        // Store transactions
        let (txs_batch, txs_hashes) = self.transactions.insert_batch(&block.txs);
        trees.push(self.transactions.main.clone());
        batches.push(txs_batch);

        // Store transactions_locations
        let txs_locations_batch =
            self.transactions.insert_batch_location(&txs_hashes, block.header.height);
        trees.push(self.transactions.location.clone());
        batches.push(txs_locations_batch);

        // Perform an atomic transaction over the trees and apply the batches.
        self.atomic_write(&trees, &batches)?;

        Ok(block_hash)
    }

    /// Check if the given [`BlockInfo`] is in the database and all trees.
    pub fn has_block(&self, block: &BlockInfo) -> Result<bool> {
        let blockhash = match self.blocks.get_order(&[block.header.height], true) {
            Ok(v) => v[0].unwrap(),
            Err(_) => return Ok(false),
        };

        // Check if we have all transactions
        let txs: Vec<TransactionHash> = block.txs.iter().map(|tx| tx.hash()).collect();
        if self.transactions.get(&txs, true).is_err() {
            return Ok(false)
        }

        // Check provided info produces the same hash
        Ok(blockhash == block.hash())
    }

    /// Retrieve [`BlockInfo`]s by given hashes. Fails if any of them is not found.
    pub fn get_blocks_by_hash(&self, hashes: &[HeaderHash]) -> Result<Vec<BlockInfo>> {
        let blocks = self.blocks.get(hashes, true)?;
        let blocks: Vec<Block> = blocks.iter().map(|x| x.clone().unwrap()).collect();
        let ret = self.get_blocks_infos(&blocks)?;

        Ok(ret)
    }

    /// Retrieve all [`BlockInfo`] for given slice of [`Block`].
    /// Fails if any of them is not found
    fn get_blocks_infos(&self, blocks: &[Block]) -> Result<Vec<BlockInfo>> {
        let mut ret = Vec::with_capacity(blocks.len());
        for block in blocks {
            let headers = self.headers.get(&[block.header], true)?;
            // Since we used strict get, its safe to unwrap here
            let header = headers[0].clone().unwrap();

            let txs = self.transactions.get(&block.txs, true)?;
            let txs = txs.iter().map(|x| x.clone().unwrap()).collect();

            let info = BlockInfo::new(header, txs, block.signature);
            ret.push(info);
        }

        Ok(ret)
    }

    /// Retrieve [`BlockInfo`]s by given heights. Does not fail if any of them are not found.
    pub fn get_blocks_by_heights(&self, heights: &[u32]) -> Result<Vec<BlockInfo>> {
        debug!(target: "blockchain", "get_blocks_by_heights(): {heights:?}");
        let blockhashes = self.blocks.get_order(heights, false)?;

        let mut hashes = vec![];
        for i in blockhashes.into_iter().flatten() {
            hashes.push(i);
        }

        self.get_blocks_by_hash(&hashes)
    }

    /// Retrieve [`Header`]s by given hashes. Fails if any of them is not found.
    pub fn get_headers_by_hash(&self, hashes: &[HeaderHash]) -> Result<Vec<Header>> {
        let headers = self.headers.get(hashes, true)?;
        let ret: Vec<Header> = headers.iter().map(|x| x.clone().unwrap()).collect();

        Ok(ret)
    }

    /// Retrieve [`Header`]s by given heights. Fails if any of them is not found.
    pub fn get_headers_by_heights(&self, heights: &[u32]) -> Result<Vec<Header>> {
        debug!(target: "blockchain", "get_headers_by_heights(): {heights:?}");
        let blockhashes = self.blocks.get_order(heights, true)?;

        let mut hashes = vec![];
        for i in blockhashes.into_iter().flatten() {
            hashes.push(i);
        }

        self.get_headers_by_hash(&hashes)
    }

    /// Retrieve n headers before given block height.
    pub fn get_headers_before(&self, height: u32, n: usize) -> Result<Vec<Header>> {
        debug!(target: "blockchain", "get_headers_before(): {height} -> {n}");
        let hashes = self.blocks.get_before(height, n)?;
        let headers = self.headers.get(&hashes, true)?;
        Ok(headers.iter().map(|h| h.clone().unwrap()).collect())
    }

    /// Retrieve stored blocks count
    pub fn len(&self) -> usize {
        self.blocks.len()
    }

    /// Retrieve stored txs count
    pub fn txs_len(&self) -> usize {
        self.transactions.len()
    }

    /// Check if blockchain contains any blocks
    pub fn is_empty(&self) -> bool {
        self.blocks.is_empty()
    }

    /// Retrieve genesis (first) block height and hash.
    pub fn genesis(&self) -> Result<(u32, HeaderHash)> {
        self.blocks.get_first()
    }

    /// Retrieve genesis (first) block info.
    pub fn genesis_block(&self) -> Result<BlockInfo> {
        let (_, hash) = self.genesis()?;
        Ok(self.get_blocks_by_hash(&[hash])?[0].clone())
    }

    /// Retrieve the last block height and hash.
    pub fn last(&self) -> Result<(u32, HeaderHash)> {
        self.blocks.get_last()
    }

    /// Retrieve the last block header.
    pub fn last_header(&self) -> Result<Header> {
        let (_, hash) = self.last()?;
        Ok(self.headers.get(&[hash], true)?[0].clone().unwrap())
    }

    /// Retrieve the last block info.
    pub fn last_block(&self) -> Result<BlockInfo> {
        let (_, hash) = self.last()?;
        Ok(self.get_blocks_by_hash(&[hash])?[0].clone())
    }

    /// Retrieve the last block difficulty. If the tree is empty,
    /// returns `BlockDifficulty::genesis` difficulty.
    pub fn last_block_difficulty(&self) -> Result<BlockDifficulty> {
        if let Some(found) = self.blocks.get_last_difficulty()? {
            return Ok(found)
        }

        let genesis_block = self.genesis_block()?;
        Ok(BlockDifficulty::genesis(genesis_block.header.timestamp))
    }

    /// Check if block order for the given height is in the database.
    pub fn has_height(&self, height: u32) -> Result<bool> {
        let vec = match self.blocks.get_order(&[height], true) {
            Ok(v) => v,
            Err(_) => return Ok(false),
        };
        Ok(!vec.is_empty())
    }

    /// Insert a given slice of pending transactions into the blockchain database.
    /// On success, the function returns the transaction hashes in the same order
    /// as the input transactions.
    pub fn add_pending_txs(&self, txs: &[Transaction]) -> Result<Vec<TransactionHash>> {
        let (txs_batch, txs_hashes) = self.transactions.insert_batch_pending(txs);
        let txs_order_batch = self.transactions.insert_batch_pending_order(&txs_hashes)?;

        // Perform an atomic transaction over the trees and apply the batches.
        let trees = [self.transactions.pending.clone(), self.transactions.pending_order.clone()];
        let batches = [txs_batch, txs_order_batch];
        self.atomic_write(&trees, &batches)?;

        Ok(txs_hashes)
    }

    /// Retrieve all transactions from the pending tx store.
    /// Be careful as this will try to load everything in memory.
    pub fn get_pending_txs(&self) -> Result<Vec<Transaction>> {
        let txs = self.transactions.get_all_pending()?;
        let indexes = self.transactions.get_all_pending_order()?;
        if txs.len() != indexes.len() {
            return Err(Error::InvalidInputLengths)
        }

        let mut ret = Vec::with_capacity(txs.len());
        for index in indexes {
            ret.push(txs.get(&index.1).unwrap().clone());
        }

        Ok(ret)
    }

    /// Remove a given slice of pending transactions from the blockchain database.
    pub fn remove_pending_txs(&self, txs: &[Transaction]) -> Result<()> {
        let txs_hashes: Vec<TransactionHash> = txs.iter().map(|tx| tx.hash()).collect();
        self.remove_pending_txs_hashes(&txs_hashes)
    }

    /// Remove a given slice of pending transactions hashes from the blockchain database.
    pub fn remove_pending_txs_hashes(&self, txs: &[TransactionHash]) -> Result<()> {
        let indexes = self.transactions.get_all_pending_order()?;
        // We could do indexes.iter().map(|x| txs.contains(x.1)).collect.map(|x| x.0).collect
        // but this is faster since we don't do the second iteration
        let mut removed_indexes = vec![];
        for index in indexes {
            if txs.contains(&index.1) {
                removed_indexes.push(index.0);
            }
        }

        let txs_batch = self.transactions.remove_batch_pending(txs);
        let txs_order_batch = self.transactions.remove_batch_pending_order(&removed_indexes);

        // Perform an atomic transaction over the trees and apply the batches.
        let trees = [self.transactions.pending.clone(), self.transactions.pending_order.clone()];
        let batches = [txs_batch, txs_order_batch];
        self.atomic_write(&trees, &batches)?;

        Ok(())
    }

    /// Remove all transactions from the pending tx store not in the
    /// provided vector and rebuild the remaining ones order.
    pub fn reset_pending_txs(&self, exclude_txs: &[TransactionHash]) -> Result<()> {
        let mut txs = vec![];
        let mut removed_txs = vec![];
        for tx in self.transactions.get_all_pending()?.keys() {
            if exclude_txs.contains(tx) {
                txs.push(*tx);
                continue
            }
            removed_txs.push(*tx);
        }
        let indexes: Vec<u64> =
            self.transactions.get_all_pending_order()?.iter().map(|(k, _)| *k).collect();

        let txs_batch = self.transactions.remove_batch_pending(&removed_txs);
        let txs_order_batch = self.transactions.remove_batch_pending_order(&indexes);
        let txs_new_order_batch = self.transactions.insert_batch_pending_order(&txs)?;

        // Perform an atomic transaction over the trees and apply the batches.
        let trees = [
            self.transactions.pending.clone(),
            self.transactions.pending_order.clone(),
            self.transactions.pending_order.clone(),
        ];
        let batches = [txs_batch, txs_order_batch, txs_new_order_batch];
        self.atomic_write(&trees, &batches)?;

        Ok(())
    }

    /// Auxiliary function to write to multiple trees completely atomic.
    fn atomic_write(&self, trees: &[sled::Tree], batches: &[sled::Batch]) -> Result<()> {
        if trees.len() != batches.len() {
            return Err(Error::InvalidInputLengths)
        }

        trees.transaction(|trees| {
            for (index, tree) in trees.iter().enumerate() {
                tree.apply_batch(&batches[index])?;
            }

            Ok::<(), sled::transaction::ConflictableTransactionError<sled::Error>>(())
        })?;

        Ok(())
    }

    /// Retrieve all blocks contained in the blockchain in order.
    /// Be careful as this will try to load everything in memory.
    pub fn get_all(&self) -> Result<Vec<BlockInfo>> {
        let order = self.blocks.get_all_order()?;
        let order: Vec<HeaderHash> = order.iter().map(|x| x.1).collect();
        let blocks = self.get_blocks_by_hash(&order)?;

        Ok(blocks)
    }

    /// Retrieve [`BlockInfo`]s by given heights range.
    pub fn get_by_range(&self, start: u32, end: u32) -> Result<Vec<BlockInfo>> {
        let blockhashes = self.blocks.get_order_by_range(start, end)?;
        let hashes: Vec<HeaderHash> = blockhashes.into_iter().map(|(_, hash)| hash).collect();
        self.get_blocks_by_hash(&hashes)
    }

    /// Retrieve last 'N' [`BlockInfo`]s from the blockchain.
    pub fn get_last_n(&self, n: usize) -> Result<Vec<BlockInfo>> {
        let records = self.blocks.get_last_n_orders(n)?;

        let mut last_n = vec![];
        for record in records {
            let header_hash = record.1;
            let blocks = self.get_blocks_by_hash(&[header_hash])?;
            for block in blocks {
                last_n.push(block.clone());
            }
        }

        Ok(last_n)
    }

    /// Auxiliary function to reset the blockchain and consensus state
    /// to the provided block height.
    pub fn reset_to_height(&self, height: u32) -> Result<()> {
        // First we grab the last block height
        let (last, _) = self.last()?;

        // Check if request height is after our last height
        if height >= last {
            return Ok(())
        }

        // Grab all state inverse diffs until requested height,
        // going backwards.
        let heights: Vec<u32> = (height + 1..=last).rev().collect();
        let inverse_diffs = self.blocks.get_state_inverse_diff(&heights, true)?;

        // Create an overlay to apply the reverse diffs
        let overlay = BlockchainOverlay::new(self)?;

        // Apply the inverse diffs sequence
        let overlay_lock = overlay.lock().unwrap();
        let mut lock = overlay_lock.overlay.lock().unwrap();
        for inverse_diff in inverse_diffs {
            // Since we used strict retrieval it's safe to unwrap here
            let inverse_diff = inverse_diff.unwrap();
            lock.add_diff(&inverse_diff)?;
            lock.apply_diff(&inverse_diff)?;
            self.sled_db.flush()?;
        }
        drop(lock);
        drop(overlay_lock);

        Ok(())
    }

    /// Grab the RandomX VM current and next key, based on provided key
    /// changing height and delay. Optionally, a height can be provided
    /// to get the keys before it.
    ///
    /// NOTE: the height calculation logic is verified using test:
    //        test_randomx_keys_retrieval_logic
    pub fn get_randomx_vm_keys(
        &self,
        key_change_height: &u32,
        key_change_delay: &u32,
        height: Option<u32>,
    ) -> Result<(HeaderHash, Option<HeaderHash>)> {
        // Grab last known block header
        let last = match height {
            Some(h) => &self.get_headers_by_heights(&[if h != 0 { h - 1 } else { 0 }])?[0],
            None => &self.last_header()?,
        };

        // Check if we passed the first key change height
        if &last.height <= key_change_height {
            // Genesis is our current
            let current = self.genesis()?.1;

            // Check if last known block header is the next key
            let next = if &last.height == key_change_height { Some(last.hash()) } else { None };

            return Ok((current, next))
        }

        // Find the current and next key based on distance of last
        // known block header height from the key change height.
        let distance = last.height % key_change_height;

        // When distance is 0, current key is the block header
        // located at last_height - key_change_height height, while
        // last known block header is the next key.
        if distance == 0 {
            return Ok((
                self.get_headers_by_heights(&[last.height - key_change_height])?[0].hash(),
                Some(last.hash()),
            ))
        }

        // When distance is less than key change delay, current key
        // is the block header located at last_height - (distance + key_change_height)
        // height, while the block header located at last_height - distance
        // height is the next key.
        if &distance < key_change_delay {
            return Ok((
                self.get_headers_by_heights(&[last.height - (distance + key_change_height)])?[0]
                    .hash(),
                Some(self.get_headers_by_heights(&[last.height - distance])?[0].hash()),
            ))
        }

        // When distance is greater or equal to key change delay,
        // current key is the block header located at last_height - distance
        // height and we don't know the next key.
        let current = self.get_headers_by_heights(&[last.height - distance])?[0].hash();
        Ok((current, None))
    }
}

/// Atomic pointer to sled db overlay.
pub type SledDbOverlayPtr = Arc<Mutex<sled_overlay::SledDbOverlay>>;

/// Atomic pointer to blockchain overlay.
pub type BlockchainOverlayPtr = Arc<Mutex<BlockchainOverlay>>;

/// Overlay structure over a [`Blockchain`] instance.
pub struct BlockchainOverlay {
    /// Main [`sled_overlay::SledDbOverlay`] to the sled db connection
    pub overlay: SledDbOverlayPtr,
    /// Headers overlay
    pub headers: HeaderStoreOverlay,
    /// Blocks overlay
    pub blocks: BlockStoreOverlay,
    /// Transactions overlay
    pub transactions: TxStoreOverlay,
    /// Contract overlay
    pub contracts: ContractStoreOverlay,
}

impl BlockchainOverlay {
    /// Instantiate a new `BlockchainOverlay` over the given [`Blockchain`] instance.
    pub fn new(blockchain: &Blockchain) -> Result<BlockchainOverlayPtr> {
        // Here we configure all our blockchain sled trees to be protected in the overlay
        let protected_trees = vec![
            SLED_BLOCK_TREE,
            SLED_BLOCK_ORDER_TREE,
            SLED_BLOCK_DIFFICULTY_TREE,
            SLED_BLOCK_STATE_INVERSE_DIFF_TREE,
            SLED_HEADER_TREE,
            SLED_SYNC_HEADER_TREE,
            SLED_TX_TREE,
            SLED_TX_LOCATION_TREE,
            SLED_PENDING_TX_TREE,
            SLED_PENDING_TX_ORDER_TREE,
            SLED_CONTRACTS_TREE,
            SLED_CONTRACTS_TREES_TREE,
            SLED_BINCODE_TREE,
        ];
        let overlay = Arc::new(Mutex::new(sled_overlay::SledDbOverlay::new(
            &blockchain.sled_db,
            protected_trees,
        )));
        let headers = HeaderStoreOverlay::new(&overlay)?;
        let blocks = BlockStoreOverlay::new(&overlay)?;
        let transactions = TxStoreOverlay::new(&overlay)?;
        let contracts = ContractStoreOverlay::new(&overlay)?;

        Ok(Arc::new(Mutex::new(Self { overlay, headers, blocks, transactions, contracts })))
    }

    /// Check if blockchain contains any blocks
    pub fn is_empty(&self) -> Result<bool> {
        self.blocks.is_empty()
    }

    /// Retrieve the last block height and hash.
    pub fn last(&self) -> Result<(u32, HeaderHash)> {
        self.blocks.get_last()
    }

    /// Retrieve the last block info.
    pub fn last_block(&self) -> Result<BlockInfo> {
        let (_, hash) = self.last()?;
        Ok(self.get_blocks_by_hash(&[hash])?[0].clone())
    }

    /// Retrieve the last block height.
    pub fn last_block_height(&self) -> Result<u32> {
        Ok(self.last()?.0)
    }

    /// Retrieve the last block timestamp.
    pub fn last_block_timestamp(&self) -> Result<Timestamp> {
        let (_, hash) = self.last()?;
        Ok(self.get_blocks_by_hash(&[hash])?[0].header.timestamp)
    }

    /// Insert a given [`BlockInfo`] into the overlay.
    /// This functions wraps all the logic of separating the block into specific
    /// data that can be fed into the different trees of the overlay.
    /// Upon success, the functions returns the block hash that
    /// were given and appended to the overlay.
    /// Since we are adding to the overlay, we don't need to exeucte
    /// the writes atomically.
    pub fn add_block(&self, block: &BlockInfo) -> Result<HeaderHash> {
        // Store header
        self.headers.insert(slice::from_ref(&block.header))?;

        // Store block
        let blk: Block = Block::from_block_info(block);
        let txs_hashes = blk.txs.clone();
        let block_hash = self.blocks.insert(&[blk])?[0];
        let block_hash_vec = [block_hash];

        // Store block order
        self.blocks.insert_order(&[block.header.height], &block_hash_vec)?;

        // Store transactions
        self.transactions.insert(&block.txs)?;

        // Store transactions locations
        self.transactions.insert_location(&txs_hashes, block.header.height)?;

        Ok(block_hash)
    }

    /// Check if the given [`BlockInfo`] is in the database and all trees.
    pub fn has_block(&self, block: &BlockInfo) -> Result<bool> {
        let blockhash = match self.blocks.get_order(&[block.header.height], true) {
            Ok(v) => v[0].unwrap(),
            Err(_) => return Ok(false),
        };

        // Check if we have all transactions
        let txs: Vec<TransactionHash> = block.txs.iter().map(|tx| tx.hash()).collect();
        if self.transactions.get(&txs, true).is_err() {
            return Ok(false)
        }

        // Check provided info produces the same hash
        Ok(blockhash == block.hash())
    }

    /// Retrieve [`Header`]s by given hashes. Fails if any of them is not found.
    pub fn get_headers_by_hash(&self, hashes: &[HeaderHash]) -> Result<Vec<Header>> {
        let headers = self.headers.get(hashes, true)?;
        let ret: Vec<Header> = headers.iter().map(|x| x.clone().unwrap()).collect();

        Ok(ret)
    }

    /// Retrieve [`BlockInfo`]s by given hashes. Fails if any of them is not found.
    pub fn get_blocks_by_hash(&self, hashes: &[HeaderHash]) -> Result<Vec<BlockInfo>> {
        let blocks = self.blocks.get(hashes, true)?;
        let blocks: Vec<Block> = blocks.iter().map(|x| x.clone().unwrap()).collect();
        let ret = self.get_blocks_infos(&blocks)?;

        Ok(ret)
    }

    /// Retrieve all [`BlockInfo`] for given slice of [`Block`].
    /// Fails if any of them is not found
    fn get_blocks_infos(&self, blocks: &[Block]) -> Result<Vec<BlockInfo>> {
        let mut ret = Vec::with_capacity(blocks.len());
        for block in blocks {
            let headers = self.headers.get(&[block.header], true)?;
            // Since we used strict get, its safe to unwrap here
            let header = headers[0].clone().unwrap();

            let txs = self.transactions.get(&block.txs, true)?;
            let txs = txs.iter().map(|x| x.clone().unwrap()).collect();

            let info = BlockInfo::new(header, txs, block.signature);
            ret.push(info);
        }

        Ok(ret)
    }

    /// Retrieve [`Block`]s by given hashes and return their transactions hashes.
    pub fn get_blocks_txs_hashes(&self, hashes: &[HeaderHash]) -> Result<Vec<TransactionHash>> {
        let blocks = self.blocks.get(hashes, true)?;
        let mut ret = vec![];
        for block in blocks {
            ret.extend_from_slice(&block.unwrap().txs);
        }

        Ok(ret)
    }

    /// Checkpoint overlay so we can revert to it, if needed.
    pub fn checkpoint(&self) {
        self.overlay.lock().unwrap().checkpoint();
    }

    /// Revert to current overlay checkpoint.
    pub fn revert_to_checkpoint(&self) {
        self.overlay.lock().unwrap().revert_to_checkpoint();
    }

    /// Auxiliary function to create a full clone using SledDbOverlay::clone,
    /// generating new pointers for the underlying overlays.
    pub fn full_clone(&self) -> Result<BlockchainOverlayPtr> {
        let overlay = Arc::new(Mutex::new(self.overlay.lock().unwrap().clone()));
        let headers = HeaderStoreOverlay::new(&overlay)?;
        let blocks = BlockStoreOverlay::new(&overlay)?;
        let transactions = TxStoreOverlay::new(&overlay)?;
        let contracts = ContractStoreOverlay::new(&overlay)?;

        Ok(Arc::new(Mutex::new(Self { overlay, headers, blocks, transactions, contracts })))
    }
}

/// Parse a sled record in the form of a tuple (`key`, `value`).
pub fn parse_record<T1: Decodable, T2: Decodable>(record: (IVec, IVec)) -> Result<(T1, T2)> {
    let key = deserialize(&record.0)?;
    let value = deserialize(&record.1)?;

    Ok((key, value))
}

/// Parse a sled record with a u32 key, encoded in Big Endian bytes,
/// in the form of a tuple (`key`, `value`).
pub fn parse_u32_key_record<T: Decodable>(record: (IVec, IVec)) -> Result<(u32, T)> {
    let key_bytes: [u8; 4] = record.0.as_ref().try_into().unwrap();
    let key = u32::from_be_bytes(key_bytes);
    let value = deserialize(&record.1)?;

    Ok((key, value))
}

/// Parse a sled record with a u64 key, encoded in Big Endian bytes,
/// in the form of a tuple (`key`, `value`).
pub fn parse_u64_key_record<T: Decodable>(record: (IVec, IVec)) -> Result<(u64, T)> {
    let key_bytes: [u8; 8] = record.0.as_ref().try_into().unwrap();
    let key = u64::from_be_bytes(key_bytes);
    let value = deserialize(&record.1)?;

    Ok((key, value))
}

#[cfg(feature = "async-serial")]
/// Parse a sled record in the form of a tuple (`key`, `value`).
pub async fn parse_record_async<T1: AsyncDecodable, T2: AsyncDecodable>(
    record: (IVec, IVec),
) -> Result<(T1, T2)> {
    let key = deserialize_async(&record.0).await?;
    let value = deserialize_async(&record.1).await?;

    Ok((key, value))
}

#[cfg(feature = "async-serial")]
/// Parse a sled record with a u32 key, encoded in Big Endian bytes,
/// in the form of a tuple (`key`, `value`).
pub async fn parse_u32_key_record_async<T: AsyncDecodable>(
    record: (IVec, IVec),
) -> Result<(u32, T)> {
    let key_bytes: [u8; 4] = record.0.as_ref().try_into().unwrap();
    let key = u32::from_be_bytes(key_bytes);
    let value = deserialize_async(&record.1).await?;

    Ok((key, value))
}

#[cfg(feature = "async-serial")]
/// Parse a sled record with a u64 key, encoded in Big Endian bytes,
/// in the form of a tuple (`key`, `value`).
pub async fn parse_u64_key_record_async<T: AsyncDecodable>(
    record: (IVec, IVec),
) -> Result<(u64, T)> {
    let key_bytes: [u8; 8] = record.0.as_ref().try_into().unwrap();
    let key = u64::from_be_bytes(key_bytes);
    let value = deserialize_async(&record.1).await?;

    Ok((key, value))
}

#[cfg(test)]
mod tests {
    use crate::validator::pow::{RANDOMX_KEY_CHANGE_DELAY, RANDOMX_KEY_CHANGING_HEIGHT};

    /// Compute the RandomX VM current and next key heights, based on
    /// provided key changing height and delay.
    fn get_randomx_vm_keys_heights(last: u32) -> (u32, Option<u32>) {
        // Check if we passed the first key change height
        if last <= RANDOMX_KEY_CHANGING_HEIGHT {
            // Genesis is our current
            let current = 0;

            // Check if last height is the next key height
            let next = if last == RANDOMX_KEY_CHANGING_HEIGHT { Some(last) } else { None };

            return (current, next)
        }

        // Find the current and next key based on distance of last
        // height from the key change height.
        let distance = last % RANDOMX_KEY_CHANGING_HEIGHT;

        // When distance is 0, current key is the last_height - RANDOMX_KEY_CHANGING_HEIGHT
        // height, while last is the next key.
        if distance == 0 {
            return (last - RANDOMX_KEY_CHANGING_HEIGHT, Some(last))
        }

        // When distance is less than key change delay, current key
        // is the last_height - (distance + RANDOMX_KEY_CHANGING_HEIGHT) height,
        // while the last_height - distance height is the next key.
        if distance < RANDOMX_KEY_CHANGE_DELAY {
            return (last - (distance + RANDOMX_KEY_CHANGING_HEIGHT), Some(last - distance))
        }

        // When distance is greater or equal to key change delay,
        // current key is the last_height - distance height and we
        // don't know the next key height.
        let current = last - distance;
        (current, None)
    }

    #[test]
    fn test_randomx_keys_retrieval_logic() {
        // last < RANDOMX_KEY_CHANGING_HEIGHT(2048)
        let (current, next) = get_randomx_vm_keys_heights(2047);
        assert_eq!(current, 0);
        assert!(next.is_none());

        // last == RANDOMX_KEY_CHANGING_HEIGHT(2048)
        let (current, next) = get_randomx_vm_keys_heights(2048);
        assert_eq!(current, 0);
        assert_eq!(next, Some(2048));

        // last > RANDOMX_KEY_CHANGING_HEIGHT(2048)
        // last % RANDOMX_KEY_CHANGING_HEIGHT(2048) == 0
        let (current, next) = get_randomx_vm_keys_heights(4096);
        assert_eq!(current, 2048);
        assert_eq!(next, Some(4096));

        // last % RANDOMX_KEY_CHANGING_HEIGHT(2048) < RANDOMX_KEY_CHANGE_DELAY(64)
        let (current, next) = get_randomx_vm_keys_heights(4097);
        assert_eq!(current, 2048);
        assert_eq!(next, Some(4096));

        // last % RANDOMX_KEY_CHANGING_HEIGHT(2048) == RANDOMX_KEY_CHANGE_DELAY(64)
        let (current, next) = get_randomx_vm_keys_heights(4160);
        assert_eq!(current, 4096);
        assert!(next.is_none());

        // last % RANDOMX_KEY_CHANGING_HEIGHT(2048) > RANDOMX_KEY_CHANGE_DELAY(64)
        let (current, next) = get_randomx_vm_keys_heights(4161);
        assert_eq!(current, 4096);
        assert!(next.is_none());
    }
}