cuprate_blockchain/ops/

block.rs

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

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::{CRYPTONOTE_PRUNING_LOG_STRIPES, CRYPTONOTE_PRUNING_STRIPE_SIZE};
use cuprate_types::{
    AltBlockInformation, BlockCompleteEntry, ChainId, ExtendedBlockHeader, HardFork,
    PrunedTxBlobEntry, TransactionBlobs, VerifiedBlockInformation, VerifiedTransactionInformation,
};

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

use crate::{
    database::CHAIN_TIP_KEY,
    error::{BlockchainError, DbResult},
    ops::{
        alt_block,
        tx::{add_tx_info_to_dynamic_tables, add_tx_info_to_tapes, 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,
        tape: &tapes::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)
    }

    /// 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 = cuprate_pruning::DecompressedPruningSeed::new(
        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, 500_000_000)
        .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;
        }

        // 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();
        let mut v2_prunable_index = write_v2_prunable_data(
            append_tx,
            &db.prunable_blobs
                [usize::try_from(stripe).expect("stripe will not exceed usize::MAX") - 1],
            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.
                    0,                              // miner txs will never be pruned
                    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,
                    prunable_blob_idx: block_v2_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)]
        {
            // Make sure the given tx is correct.
            let tx_full =
                crate::ops::tx::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.
///
/// 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)> {
    // 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 remove_tx_iter = block.transactions.iter().map(|tx_hash| {
        let (_, tx) = remove_tx_from_dynamic_tables(db, tx_hash, tx_rw, tapes)?;
        Ok::<_, BlockchainError>(tx)
    });

    if let Some(chain_id) = move_to_alt_chain {
        let txs = remove_tx_iter
            .map(|result| {
                let tx = result?;
                let tx_weight = tx.weight();
                let tx_hash = tx.hash();
                let fee = tx_fee(&tx);
                let (tx_pruned, prunable) = tx.pruned_with_prunable();

                Ok(VerifiedTransactionInformation {
                    tx_weight,
                    tx_pruned: tx_pruned.serialize(),
                    tx_prunable_blob: prunable,
                    tx_hash,
                    fee,
                    tx: tx_pruned,
                })
            })
            .collect::<DbResult<Vec<VerifiedTransactionInformation>>>()?;

        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,
        )?;
    } else {
        for result in remove_tx_iter {
            drop(result?);
        }
    }

    // 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();
    tapes.truncate_blob_tape(
        &db.prunable_blobs[usize::try_from(stripe).expect("stripe will not exceed usize::MAX") - 1],
        block_info.prunable_blob_idx,
    );

    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))
}

//---------------------------------------------------------------------------------------------------- `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: &tapes::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)?;

    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 v1_len, mut v2_len) = (0, 0);
            for t in &txs {
                if t.is_v1_tx() {
                    v1_len += t.prunable_size;
                } else {
                    v2_len += t.prunable_size;
                }
            }
            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 = read_blob(
                tapes,
                &db.prunable_blobs[usize::try_from(pruning_stripe)
                    .expect("stripe will not exceed usize::MAX")
                    - 1],
                block_info.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(),
    )))
}