cuprate_blockchain/ops/

block.rs

//! Block functions.
use std::{borrow::Cow, cmp::min, collections::HashMap, io};

use bytes::{Buf, Bytes};
use fjall::Readable;
use monero_oxide::{
    block::{Block, BlockHeader},
    transaction::{Pruned, Transaction},
};
use tapes::{BlobTape, TapesAppend, TapesRead, TapesTruncate};
use tracing::instrument;

use cuprate_constants::block::MAX_BLOCK_HEIGHT_USIZE;
use cuprate_helper::{
    cast::{u64_to_usize, usize_to_u64},
    map::{combine_low_high_bits_to_u128, split_u128_into_low_high_bits},
    tx::tx_fee,
};
use cuprate_pruning::{
    PruningSeed, CRYPTONOTE_PRUNING_LOG_STRIPES, CRYPTONOTE_PRUNING_STRIPE_SIZE,
    CRYPTONOTE_PRUNING_TIP_BLOCKS,
};
use cuprate_types::{
    AltBlockInformation, BlockCompleteEntry, ChainId, ExtendedBlockHeader, HardFork,
    PrunedTxBlobEntry, TransactionBlobs, VerifiedBlockInformation, VerifiedTransactionInformation,
};

use crate::{
    database::{PrunableTables, CHAIN_TIP_KEY},
    error::{BlockchainError, DbResult},
    ops::{
        alt_block,
        blockchain::chain_height,
        tx::{
            add_tx_info_to_dynamic_tables, add_tx_info_to_tapes, get_tx_from_id,
            remove_tx_from_dynamic_tables,
        },
    },
    types::{Amount, BlockHash, BlockHeight, BlockInfo},
    BlockchainDatabase,
};

/// Write a slice of contiguous blocks to the tapes database.
///
/// The blocks must follow directly from the top of the chain.
///
/// # Panic
///
/// This will panic if the given blocks cross 3 pruning stripes.
#[instrument(skip_all, level = "info")]
pub fn add_blocks_to_tapes(
    blocks: &[VerifiedBlockInformation],
    db: &BlockchainDatabase,
    append_tx: &mut tapes::TapesAppendTransaction,
) -> DbResult<()> {
    /// A helper function to write the v2 prunable data, returning the index of the first v2 prunable byte.
    fn write_v2_prunable_data(
        append_tx: &mut tapes::TapesAppendTransaction,
        stripe: u32,
        prunable_tables: &PrunableTables,
        blocks: &[VerifiedBlockInformation],
    ) -> io::Result<u64> {
        fn write_v2_prunable_data_inner(
            append_tx: &mut tapes::TapesAppendTransaction,
            tape: &impl BlobTape,
            blocks: &[VerifiedBlockInformation],
        ) -> io::Result<u64> {
            let first_idx = append_tx
                .blob_tape_len(tape)
                .expect("Required tape not found");
            for block in blocks {
                for tx in &block.txs {
                    if tx.tx.version() != 1 {
                        append_tx.append_bytes(tape, tx.tx_prunable_blob.as_slice())?;
                    }
                }
            }

            Ok(first_idx)
        }

        if let Some(prunable_tape) = prunable_tables.try_get_prunable_tape(stripe) {
            write_v2_prunable_data_inner(append_tx, prunable_tape, blocks)
        } else {
            let PrunableTables::Pruned {
                prunable_tip_blobs, ..
            } = prunable_tables
            else {
                unreachable!()
            };
            write_v2_prunable_data_inner(append_tx, prunable_tip_blobs, blocks)
        }
    }

    /// A helper function to write the v1 prunable data, returning the index of the first v1 prunable byte.
    fn write_v1_prunable_data(
        append_tx: &mut tapes::TapesAppendTransaction,
        db: &BlockchainDatabase,
        blocks: &[VerifiedBlockInformation],
    ) -> io::Result<u64> {
        let first_idx = append_tx
            .blob_tape_len(&db.v1_prunable_blobs)
            .expect("Required tape not found");

        for block in blocks {
            for tx in &block.txs {
                if tx.tx.version() == 1 {
                    append_tx.append_bytes(&db.v1_prunable_blobs, &tx.tx_prunable_blob)?;
                }
            }
        }

        Ok(first_idx)
    }

    // First fill in the `pruned_blobs` tape.
    let mut pruned_tape_index = append_tx.blob_tape_len(&db.pruned_blobs).unwrap_or(0);
    for block in blocks {
        append_tx.append_bytes(&db.pruned_blobs, &block.block_blob)?;

        for tx in &block.txs {
            append_tx.append_bytes(&db.pruned_blobs, tx.tx_pruned.as_slice())?;

            let prunable_hash = if tx.tx_prunable_blob.is_empty() || tx.tx.version() == 1 {
                [0; 32]
            } else {
                monero_oxide::primitives::keccak256(&tx.tx_prunable_blob)
            };
            append_tx.append_bytes(&db.pruned_blobs, &prunable_hash)?;
        }
    }

    tracing::trace!("pruned_tape_index: {}", pruned_tape_index);

    // Split the blocks at the point the pruning stripe changes.
    let start_height = blocks[0].height;
    let first_block_pruning_seed = PruningSeed::new_pruned(
        cuprate_pruning::get_block_pruning_stripe(
            start_height,
            usize::MAX,
            CRYPTONOTE_PRUNING_LOG_STRIPES,
        )
        .unwrap(),
        CRYPTONOTE_PRUNING_LOG_STRIPES,
    )
    .unwrap();
    let next_stripe_height = first_block_pruning_seed
        .get_next_pruned_block(start_height, MAX_BLOCK_HEIGHT_USIZE)
        .unwrap()
        .unwrap();

    let (first_stripe, next_stripe) =
        blocks.split_at(min(next_stripe_height - start_height, blocks.len()));

    assert!(
        next_stripe.len() <= CRYPTONOTE_PRUNING_STRIPE_SIZE,
        "blocks cross more than 2 pruning stripes"
    );

    tracing::debug!(
        start_height,
        ?first_block_pruning_seed,
        next_stripe_height,
        first_stripe_len = first_stripe.len(),
        next_stripe_len = next_stripe.len()
    );

    let mut numb_rct_outs = append_tx
        .fixed_sized_tape_len(&db.rct_outputs)
        .expect("Required tape not found");

    // Now iterate over chunks of blocks with the same stripe.
    for blocks in [first_stripe, next_stripe] {
        if blocks.is_empty() {
            continue;
        }

        // If pruned then move the prunable tip forward.
        if let PrunableTables::Pruned {
            prunable_tip,
            prunable_tip_blobs,
            stripe: our_stripe,
            ..
        } = &db.prunable_tables
        {
            // As we split the batch into their stripes above the whole range we are removing here will
            // also be in the same stripe.
            let end_removal_height = blocks
                .last()
                .unwrap()
                .height
                .saturating_sub(CRYPTONOTE_PRUNING_TIP_BLOCKS - 1);

            let end_removal_stripe = cuprate_pruning::get_block_pruning_stripe(
                end_removal_height,
                usize::MAX,
                CRYPTONOTE_PRUNING_LOG_STRIPES,
            )
            .unwrap();

            let new_start_tx_idx = append_tx
                .read_entry(&db.block_infos, usize_to_u64(end_removal_height))?
                .map_or(0, |b| b.mining_tx_index);

            append_tx.shift_start_idx_fixed(prunable_tip, new_start_tx_idx)?;

            // Only pruned blocks are stored in `prunable_tip_blobs`.
            if end_removal_stripe != *our_stripe {
                if let Some(new_start_bytes) =
                    append_tx.read_entry(prunable_tip, new_start_tx_idx)?
                {
                    append_tx.shift_start_idx(prunable_tip_blobs, new_start_bytes)?;
                }
            }
        }

        // Get the stripe and write to the correct v2 prunable tape.
        let stripe = cuprate_pruning::get_block_pruning_stripe(
            blocks[0].height,
            usize::MAX,
            CRYPTONOTE_PRUNING_LOG_STRIPES,
        )
        .unwrap();

        // If we are pruning and this is prunable `v2_prunable_index` is the index into the tip blobs.
        let mut v2_prunable_index =
            write_v2_prunable_data(append_tx, stripe, &db.prunable_tables, blocks)?;

        // Write the v1 prunable tape for any v1 txs.
        let mut v1_prunable_index = write_v1_prunable_data(append_tx, db, blocks)?;

        tracing::debug!(
            chunk_start = blocks[0].height,
            stripe,
            v1_prunable_index,
            v2_prunable_index,
            numb_rct_outs
        );

        // Now loop over every block in the stripe.
        for block in blocks {
            let block_pruned_blob_idx = pruned_tape_index;
            let block_v1_prunable_idx = v1_prunable_index;
            let block_v2_prunable_idx = v2_prunable_index;

            let header_len = usize_to_u64(block.block.header.serialize().len());

            // Add the miner tx info to the tapes, recording the index of the miner tx.
            let mining_tx_index = {
                let tx = block.block.miner_transaction();
                add_tx_info_to_tapes(
                    &tx.clone().into(),
                    pruned_tape_index + header_len, // The miner tx will be stored after the block header.
                    v2_prunable_index,
                    tx.serialize().len(),
                    0,
                    &block.height,
                    &mut numb_rct_outs,
                    append_tx,
                    db,
                )?
            };
            // Move the pruned tape index forward by the block size (header, miner tx, tx hash list).
            pruned_tape_index += usize_to_u64(block.block_blob.len());

            // Loop over all the transactions in the block, adding their info to the tapes.
            for tx in &block.txs {
                add_tx_info_to_tapes(
                    &tx.tx,
                    pruned_tape_index,
                    // Pruned part of v1 txs will be stored in a different tape.
                    if tx.tx.version() == 1 {
                        v1_prunable_index
                    } else {
                        v2_prunable_index
                    },
                    tx.tx_pruned.len(),
                    tx.tx_prunable_blob.len(),
                    &block.height,
                    &mut numb_rct_outs,
                    append_tx,
                    db,
                )?;

                // Move the blob tapes forward by the transaction size(s). We add 32 for the pruned tape
                // as we store the prunable hash in the pruned tape.
                pruned_tape_index += usize_to_u64(tx.tx_pruned.len()) + 32;
                if tx.tx.version() == 1 {
                    v1_prunable_index += usize_to_u64(tx.tx_prunable_blob.len());
                } else {
                    v2_prunable_index += usize_to_u64(tx.tx_prunable_blob.len());
                }
            }

            // `saturating_add` is used here as cumulative generated coins overflows due to tail emission.
            let cumulative_generated_coins = append_tx
                .read_entry(
                    &db.block_infos,
                    usize_to_u64(block.height.saturating_sub(1)),
                )?
                .map_or(0, |prev| prev.cumulative_generated_coins)
                .saturating_add(block.generated_coins);

            let (cumulative_difficulty_low, cumulative_difficulty_high) =
                split_u128_into_low_high_bits(block.cumulative_difficulty);

            // Add the block info to the tapes.
            append_tx.append_entries(
                &db.block_infos,
                &[BlockInfo {
                    cumulative_difficulty_low,
                    cumulative_difficulty_high,
                    cumulative_generated_coins,
                    cumulative_rct_outs: numb_rct_outs,
                    block_hash: block.block_hash,
                    weight: block.weight,
                    long_term_weight: block.long_term_weight,
                    mining_tx_index,
                    pruned_blob_idx: block_pruned_blob_idx,
                    v1_prunable_blob_idx: block_v1_prunable_idx,
                }],
            )?;

            tracing::debug!(
                height = block.height,
                block_pruned_blob_idx,
                block_v1_prunable_idx,
                block_v2_prunable_idx,
                cumulative_generated_coins,
                "added block to tapes"
            );
        }
    }

    Ok(())
}

/// Add a [`VerifiedBlockInformation`] to the dynamic database (fjall).
///
/// This extracts all the data from the input block and
/// maps/adds them to the appropriate database tables.
///
/// # Panics
/// This function will panic if the block is invalid.
// no inline, too big.
pub fn add_block_to_dynamic_tables<'a, I: Iterator<Item = Cow<'a, Transaction<Pruned>>>>(
    db: &BlockchainDatabase,
    block: &Block,
    block_hash: &BlockHash,
    txs: I,
    numb_transactions: &mut u64,
    w: &mut fjall::OwnedWriteBatch,
    pre_rct_numb_outputs_cache: &mut HashMap<Amount, u64>,
) -> DbResult<()> {
    // Panic (should never happen) instead of allowing DB corruption.
    // <https://github.com/Cuprate/cuprate/pull/102#discussion_r1560020991>
    assert!(
        u32::try_from(block.number()).is_ok(),
        "block.height ({}) > u32::MAX",
        block.number(),
    );

    // Add the miner transaction first.
    let tx = block.miner_transaction();
    add_tx_info_to_dynamic_tables(
        db,
        &tx.clone().into(),
        *numb_transactions,
        &tx.hash(),
        &block.number(),
        w,
        pre_rct_numb_outputs_cache,
    )?;
    *numb_transactions += 1;

    for (tx_hash, tx) in block.transactions.iter().zip(txs) {
        #[cfg(debug_assertions)]
        {
            if db.pruning_seed() == PruningSeed::NotPruned {
                // Make sure the given tx is correct.
                let tx_full = get_tx_from_id(numb_transactions, &db.linear_tapes.reader(), db)?;

                let (pruned, _) = tx_full.pruned_with_prunable();

                assert_eq!(tx.as_ref(), &pruned);
            }
        }

        add_tx_info_to_dynamic_tables(
            db,
            &tx,
            *numb_transactions,
            tx_hash,
            &block.number(),
            w,
            pre_rct_numb_outputs_cache,
        )?;
        *numb_transactions += 1;
    }

    w.insert(&db.block_heights, block_hash, block.number().to_le_bytes());
    w.insert(&db.chain_tip, CHAIN_TIP_KEY, block_hash);

    Ok(())
}

//---------------------------------------------------------------------------------------------------- `pop_block`
/// Remove the top/latest block from the database.
///
/// The removed block's data is returned along with whether it was added to the alt block tables.
///
/// If a [`ChainId`] is specified the popped block will be added to the alt block tables under
/// that [`ChainId`]. Otherwise, the block will be completely removed from the DB.
// no inline, too big
pub fn pop_block(
    db: &BlockchainDatabase,
    move_to_alt_chain: Option<ChainId>,
    tx_rw: &mut fjall::OwnedWriteBatch,
    tapes: &mut tapes::TapesTruncateTransaction,
) -> DbResult<(BlockHeight, BlockHash, Block, bool)> {
    // Pop the last block info.
    let (block_height, block_info) = tapes
        .pop_fixed_sized_tape(&db.block_infos)?
        .ok_or(BlockchainError::NotFound)?;

    let block_height = usize::try_from(block_height).unwrap();

    tx_rw.remove(&db.block_heights, block_info.block_hash);

    let new_top = tapes
        .read_entry(&db.block_infos, usize_to_u64(block_height - 1))?
        .ok_or(BlockchainError::NotFound)?;
    tx_rw.insert(&db.chain_tip, CHAIN_TIP_KEY, new_top.block_hash);

    // Get the block from the database, so we know what txs to remove.
    let block = get_block(&block_height, Some(&block_info), tapes, db)?;
    //------------------------------------------------------ Transaction / Outputs / Key Images

    remove_tx_from_dynamic_tables(db, &block.miner_transaction().hash(), tx_rw, tapes)?;

    let mut add_to_alt_chain = move_to_alt_chain.is_some();
    let mut txs = Vec::with_capacity(block.transactions.len());

    for tx_hash in &block.transactions {
        let (tx_id, _) = remove_tx_from_dynamic_tables(db, tx_hash, tx_rw, tapes)?;

        if add_to_alt_chain {
            // TODO: we could just get the missing data here, `remove_tx_from_dynamic_tables` returns the pruned tx
            match get_tx_from_id(&tx_id, tapes, db) {
                Ok(tx) => {
                    let tx_weight = tx.weight();
                    let tx_hash = tx.hash();
                    let fee = tx_fee(&tx);
                    let (tx_pruned, prunable) = tx.pruned_with_prunable();

                    txs.push(VerifiedTransactionInformation {
                        tx_weight,
                        tx_pruned: tx_pruned.serialize(),
                        tx_prunable_blob: prunable,
                        tx_hash,
                        fee,
                        tx: tx_pruned,
                    });
                }
                Err(BlockchainError::NotFound) => {
                    add_to_alt_chain = false;
                    txs.clear();
                }
                Err(e) => return Err(e),
            }
        }
    }

    if let Some(chain_id) = move_to_alt_chain.filter(|_| add_to_alt_chain) {
        alt_block::add_alt_block(
            db,
            &AltBlockInformation {
                block: block.clone(),
                block_blob: block.serialize(),
                txs,
                block_hash: block_info.block_hash,
                // We know the PoW is valid for this block so just set it so it will always verify as valid.
                pow_hash: [0; 32],
                height: block_height,
                weight: block_info.weight,
                long_term_weight: block_info.long_term_weight,
                cumulative_difficulty: combine_low_high_bits_to_u128(
                    block_info.cumulative_difficulty_low,
                    block_info.cumulative_difficulty_high,
                ),
                chain_id,
            },
            tx_rw,
        )?;
    }

    // Truncate the tapes.
    tapes.truncate_blob_tape(&db.pruned_blobs, block_info.pruned_blob_idx)?;
    tapes.truncate_blob_tape(&db.v1_prunable_blobs, block_info.v1_prunable_blob_idx)?;
    let stripe = cuprate_pruning::get_block_pruning_stripe(
        block_height,
        usize::MAX,
        CRYPTONOTE_PRUNING_LOG_STRIPES,
    )
    .unwrap();

    match &db.prunable_tables {
        PrunableTables::Full(prunable_blobs) => {
            let prunable_blob_idx_end = tapes
                .read_entry(&db.tx_infos, block_info.mining_tx_index)?
                .unwrap()
                .prunable_blob_idx;

            tapes
                .truncate_blob_tape(&prunable_blobs[stripe as usize - 1], prunable_blob_idx_end)?;
        }
        PrunableTables::Pruned {
            prunable_tip,
            kept_stripe,
            stripe: our_stripe,
            ..
        } if *our_stripe == stripe => {
            let prunable_blob_idx_end = tapes
                .read_entry(&db.tx_infos, block_info.mining_tx_index)?
                .unwrap()
                .prunable_blob_idx;

            tapes.truncate_blob_tape(kept_stripe, prunable_blob_idx_end)?;
            tapes.truncate_fixed_sized_tape(prunable_tip, block_info.mining_tx_index)?;
        }
        PrunableTables::Pruned {
            prunable_tip,
            prunable_tip_blobs,
            ..
        } => {
            let prunable_blob_idx_end =
                match tapes.read_entry(prunable_tip, block_info.mining_tx_index)? {
                    Some(index) => index,
                    // The offset is gone below the rolling tip; empty the blob tape.
                    None => tapes
                        .blob_tape_start(prunable_tip_blobs)
                        .expect("required tape not open"),
                };

            tapes.truncate_blob_tape(prunable_tip_blobs, prunable_blob_idx_end)?;
            tapes.truncate_fixed_sized_tape(prunable_tip, block_info.mining_tx_index)?;
        }
    }

    tapes.truncate_fixed_sized_tape(&db.tx_infos, block_info.mining_tx_index)?;

    let cumulative_rct_outs = tapes
        .read_entry(&db.block_infos, usize_to_u64(block_height) - 1)?
        .map_or(0, |info| info.cumulative_rct_outs);

    tapes.truncate_fixed_sized_tape(&db.rct_outputs, cumulative_rct_outs)?;

    Ok((block_height, block_info.block_hash, block, add_to_alt_chain))
}

//---------------------------------------------------------------------------------------------------- `get_block_complete_entry_*`
/// Retrieve a [`BlockCompleteEntry`] from the database.
///
pub fn get_block_complete_entry(
    db: &BlockchainDatabase,
    block_hash: &BlockHash,
    pruned: bool,
    tx_ro: &fjall::Snapshot,
    tapes: &tapes::TapesReadTransaction,
) -> DbResult<BlockCompleteEntry> {
    let block_height = tx_ro
        .get(&db.block_heights, block_hash)?
        .ok_or(BlockchainError::NotFound)?;

    get_block_complete_entry_from_height(
        usize::from_le_bytes(block_height.as_ref().try_into().unwrap()),
        pruned,
        tapes,
        db,
    )
}

/// Retrieve a [`BlockCompleteEntry`] from the database.
///
pub fn get_block_complete_entry_from_height(
    block_height: BlockHeight,
    pruned: bool,
    tapes: &tapes::TapesReadTransaction,
    db: &BlockchainDatabase,
) -> DbResult<BlockCompleteEntry> {
    /// A helper function to read a span of bytes from a tape into an owned buffer.
    fn read_blob(
        tapes: &tapes::TapesReadTransaction,
        tape: &impl BlobTape,
        start: u64,
        len: usize,
    ) -> DbResult<Bytes> {
        if len == 0 {
            return Ok(Bytes::new());
        }

        let mut buf = vec![0; len];
        tapes.read_bytes(tape, start, &mut buf)?;
        Ok(Bytes::from(buf))
    }

    let block_info = tapes
        .read_entry(&db.block_infos, usize_to_u64(block_height))?
        .ok_or(BlockchainError::NotFound)?;

    // return early if we don't have this block (we pruned it)
    let chain_height = chain_height(db, tapes)?;
    if !pruned && !db.pruning_seed().has_full_block(block_height, chain_height) {
        return Err(BlockchainError::NotFound);
    }

    let block_blob_start_idx = block_info.pruned_blob_idx;
    let mut block_blob_end_idx = None;

    let mut txs = Vec::with_capacity(32);

    for tx_info in tapes.iter_from(&db.tx_infos, block_info.mining_tx_index + 1)? {
        let tx_info = tx_info?;

        if tx_info.height != block_height {
            break;
        }

        // Set the `block_blob_end_idx` to the first tx in the block.
        block_blob_end_idx.get_or_insert(tx_info.pruned_blob_idx);

        txs.push(tx_info);
    }

    let txs = if txs.is_empty() {
        TransactionBlobs::None
    } else {
        // We do just one big read of the pruned tape to get all txs blobs as they are contiguous.
        let first_blob_idx = txs.first().unwrap().pruned_blob_idx;
        let mut bytes = read_blob(
            tapes,
            &db.pruned_blobs,
            first_blob_idx,
            u64_to_usize(txs.last().unwrap().pruned_blob_idx - first_blob_idx)
                + txs.last().unwrap().pruned_size
                + 32,
        )?;

        if pruned {
            TransactionBlobs::Pruned(
                txs.iter()
                    .map(|tx_info| PrunedTxBlobEntry {
                        blob: bytes.split_to(tx_info.pruned_size),
                        prunable_hash: bytes.split_to(32).try_into().unwrap(),
                    })
                    .collect(),
            )
        } else {
            let mut v2_prunable_blob_idx = None;
            let (mut v1_len, mut v2_len) = (0, 0);
            for t in &txs {
                if t.is_v1_tx() {
                    v1_len += t.prunable_size;
                } else {
                    v2_prunable_blob_idx.get_or_insert(t.prunable_blob_idx);
                    v2_len += t.prunable_size;
                }
            }
            let v2_prunable_blob_idx = v2_prunable_blob_idx.unwrap_or(0);

            let mut v1 = read_blob(
                tapes,
                &db.v1_prunable_blobs,
                block_info.v1_prunable_blob_idx,
                v1_len,
            )?;
            let pruning_stripe = cuprate_pruning::get_block_pruning_stripe(
                block_height,
                usize::MAX,
                CRYPTONOTE_PRUNING_LOG_STRIPES,
            )
            .unwrap();

            let mut v2 = match &db.prunable_tables {
                PrunableTables::Full(prunable_blobs) => read_blob(
                    tapes,
                    &prunable_blobs[usize::try_from(pruning_stripe)
                        .expect("stripe will not exceed usize::MAX")
                        - 1],
                    v2_prunable_blob_idx,
                    v2_len,
                )?,
                PrunableTables::Pruned {
                    kept_stripe,
                    stripe,
                    ..
                } if *stripe == pruning_stripe => {
                    read_blob(tapes, kept_stripe, v2_prunable_blob_idx, v2_len)?
                }
                PrunableTables::Pruned {
                    prunable_tip,
                    prunable_tip_blobs,
                    ..
                } => {
                    let prunable_blob_idx =
                        tapes.read_entry(prunable_tip, block_info.mining_tx_index)?;

                    let Some(prunable_blob_idx) = prunable_blob_idx else {
                        return Err(BlockchainError::NotFound);
                    };

                    read_blob(tapes, prunable_tip_blobs, prunable_blob_idx, v2_len)?
                }
            };

            TransactionBlobs::Normal(
                txs.iter()
                    .map(|tx_info| {
                        let pruned = bytes.split_to(tx_info.pruned_size);
                        bytes.advance(32); // skip the interleaved prunable hash
                        let prunable = if tx_info.is_v1_tx() {
                            v1.split_to(tx_info.prunable_size)
                        } else {
                            v2.split_to(tx_info.prunable_size)
                        };
                        Bytes::from([pruned.as_ref(), prunable.as_ref()].concat())
                    })
                    .collect(),
            )
        }
    };

    let block_blob = {
        let block_blob_end_idx = block_blob_end_idx.map_or_else(
            || {
                // If the `block_blob_end_idx` has not been set then there were no txs in the block.
                // Get the next block's start index or the end of the pruned tape for the end index.
                let next_block_info =
                    tapes.read_entry(&db.block_infos, usize_to_u64(block_height + 1))?;

                if let Some(info) = next_block_info {
                    return Ok::<_, BlockchainError>(info.pruned_blob_idx);
                }

                Ok(tapes
                    .blob_tape_len(&db.pruned_blobs)
                    .expect("Required tape not found"))
            },
            Ok,
        )?;

        read_blob(
            tapes,
            &db.pruned_blobs,
            block_blob_start_idx,
            u64_to_usize(block_blob_end_idx - block_blob_start_idx),
        )?
    };

    Ok(BlockCompleteEntry {
        block: block_blob,
        txs,
        pruned,
        block_weight: if pruned {
            usize_to_u64(block_info.weight)
        } else {
            0
        },
    })
}

//---------------------------------------------------------------------------------------------------- `get_block_extended_header_*`
/// Retrieve a [`ExtendedBlockHeader`] from the database.
///
/// This extracts all the data from the database tables
/// needed to create a full `ExtendedBlockHeader`.
///
/// # Notes
/// This is more expensive than [`get_block_extended_header_from_height`]
#[inline]
pub fn get_block_extended_header(
    db: &BlockchainDatabase,
    block_hash: &BlockHash,
    tx_ro: &fjall::Snapshot,
    tapes: &tapes::TapesReadTransaction,
) -> DbResult<ExtendedBlockHeader> {
    let block_height = tx_ro
        .get(&db.block_heights, block_hash)?
        .ok_or(BlockchainError::NotFound)?;

    get_block_extended_header_from_height(
        usize::from_le_bytes(block_height.as_ref().try_into().unwrap()),
        tapes,
        db,
    )
}

/// Same as [`get_block_extended_header`] but with a [`BlockHeight`].
#[expect(
    clippy::missing_panics_doc,
    reason = "The panic is only possible with a corrupt DB"
)]
#[inline]
pub fn get_block_extended_header_from_height(
    block_height: BlockHeight,
    tapes: &tapes::TapesReadTransaction,
    db: &BlockchainDatabase,
) -> DbResult<ExtendedBlockHeader> {
    let block_info = tapes
        .read_entry(&db.block_infos, usize_to_u64(block_height))?
        .ok_or(BlockchainError::NotFound)?;
    let miner_tx_info = tapes
        .read_entry(&db.tx_infos, block_info.mining_tx_index)?
        .ok_or(BlockchainError::NotFound)?;

    let mut block_header_blob =
        vec![0; u64_to_usize(miner_tx_info.pruned_blob_idx - block_info.pruned_blob_idx)];

    tapes.read_bytes(
        &db.pruned_blobs,
        block_info.pruned_blob_idx,
        &mut block_header_blob,
    )?;

    let block_header = BlockHeader::read(&mut block_header_blob.as_slice()).unwrap();

    let cumulative_difficulty = combine_low_high_bits_to_u128(
        block_info.cumulative_difficulty_low,
        block_info.cumulative_difficulty_high,
    );

    Ok(ExtendedBlockHeader {
        cumulative_difficulty,
        version: HardFork::from_version(block_header.hardfork_version)
            .expect("Stored block must have a valid hard-fork"),
        vote: block_header.hardfork_signal,
        timestamp: block_header.timestamp,
        block_weight: block_info.weight,
        long_term_weight: block_info.long_term_weight,
    })
}

/// Return the top/latest [`ExtendedBlockHeader`] from the database.
#[inline]
pub fn get_block_extended_header_top(
    db: &BlockchainDatabase,
    tapes: &tapes::TapesReadTransaction,
) -> DbResult<(ExtendedBlockHeader, BlockHeight)> {
    let height = u64_to_usize(
        tapes
            .fixed_sized_tape_len(&db.block_infos)
            .expect("Required tape not found")
            .saturating_sub(1),
    );
    let header = get_block_extended_header_from_height(height, tapes, db)?;
    Ok((header, height))
}

//---------------------------------------------------------------------------------------------------- Block
/// Retrieve a [`Block`] via its [`BlockHeight`].
///
/// If the block info is given, it will not be looked up, which can be useful when the info is popped.
#[inline]
pub fn get_block(
    block_height: &BlockHeight,
    blocks_info: Option<&BlockInfo>,
    tapes: &impl TapesRead,
    db: &BlockchainDatabase,
) -> DbResult<Block> {
    let block_info = match blocks_info {
        Some(blocks_info) => *blocks_info,
        None => tapes
            .read_entry(&db.block_infos, usize_to_u64(*block_height))?
            .ok_or(BlockchainError::NotFound)?,
    };

    let pruned_end_blob_idx =
        match tapes.read_entry(&db.tx_infos, block_info.mining_tx_index + 1)? {
            // First check if the block has a tx then use that start as the block header end.
            Some(tx_info) if tx_info.height == *block_height => tx_info.pruned_blob_idx,
            // Otherwise the next tx is in a different block, so use the start of that block header.
            Some(_) => {
                tapes
                    .read_entry(&db.block_infos, usize_to_u64(*block_height + 1))?
                    .ok_or(BlockchainError::NotFound)?
                    .pruned_blob_idx
            }
            // If this is the top block, and it doesn't have a tx, then use the end of the pruned tape.
            None => tapes
                .blob_tape_len(&db.pruned_blobs)
                .expect("Required tape not found"),
        };

    let mut blob =
        vec![0; usize::try_from(pruned_end_blob_idx - block_info.pruned_blob_idx).unwrap()];

    tapes.read_bytes(&db.pruned_blobs, block_info.pruned_blob_idx, &mut blob)?;

    Ok(Block::read(&mut blob.as_slice())?)
}

/// Retrieve a [`Block`] via its [`BlockHash`].
#[inline]
pub fn get_block_by_hash(
    db: &BlockchainDatabase,
    block_hash: &BlockHash,
    tx_ro: &fjall::Snapshot,
    tapes: &tapes::TapesReadTransaction,
) -> DbResult<Block> {
    let block_height = tx_ro
        .get(&db.block_heights, block_hash)?
        .ok_or(BlockchainError::NotFound)?;

    get_block(
        &usize::from_le_bytes(block_height.as_ref().try_into().unwrap()),
        None,
        tapes,
        db,
    )
}

/// Retrieve a [`BlockHeight`] via its [`BlockHash`].
#[inline]
pub fn get_block_height(
    db: &BlockchainDatabase,
    block_hash: &BlockHash,
    tx_ro: &fjall::Snapshot,
) -> DbResult<BlockHeight> {
    let block_height = tx_ro
        .get(&db.block_heights, block_hash)?
        .ok_or(BlockchainError::NotFound)?;

    Ok(usize::from_le_bytes(
        block_height.as_ref().try_into().unwrap(),
    ))
}

/// Check if a block exists in the database.
///
#[inline]
pub fn block_exists(
    db: &BlockchainDatabase,
    block_hash: &BlockHash,
    tx_ro: &fjall::Snapshot,
) -> DbResult<bool> {
    Ok(tx_ro.contains_key(&db.block_heights, block_hash)?)
}

/// Returns the height of a block from its hash, only if it is in the main chain.
///
pub(crate) fn block_height(
    db: &BlockchainDatabase,
    tx_ro: &fjall::Snapshot,
    hash: &BlockHash,
) -> DbResult<Option<usize>> {
    let Some(block_height) = tx_ro.get(&db.block_heights, hash)? else {
        return Ok(None);
    };

    Ok(Some(usize::from_le_bytes(
        block_height.as_ref().try_into().unwrap(),
    )))
}