blvm_consensus/block/

script_cache.rs

//! Script verification flags and script-exec cache helpers for block validation.
//!
//! Groups base/per-tx script flags, cache insertion/merge, and BIP143 precompute
//! so block connect logic stays in the parent module.

use crate::activation::{ForkActivationTable, IsForkActive};
use crate::opcodes::*;
use crate::script::flags::{SCRIPT_VERIFY_P2SH, SCRIPT_VERIFY_TAPROOT, SCRIPT_VERIFY_WITNESS};
use crate::segwit::{Witness, is_segwit_transaction};
use crate::transaction::is_coinbase;
use crate::types::*;
use crate::witness::is_witness_empty;
#[cfg(feature = "spec-lock")]
use blvm_spec_lock::spec_locked;
#[cfg(feature = "production")]
use rustc_hash::{FxHashMap, FxHashSet};
use std::sync::LazyLock;

use super::BlockValidationContext;

// ---------------------------------------------------------------------------
// Script flags (base, per-tx, and combined)
// ---------------------------------------------------------------------------

/// Base script flags for a block from activation context.
/// Call once per block, then use `calculate_script_flags_for_block` or `add_per_tx_script_flags`.
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.5", "CalculateScriptFlags"))]
#[inline]
pub(crate) fn calculate_base_script_flags_for_block(
    height: u64,
    activation: &impl IsForkActive,
) -> u32 {
    let mut flags: u32 = 0;

    if activation.is_fork_active(ForkId::Bip16, height) {
        flags |= 0x01; // SCRIPT_VERIFY_P2SH
    }
    // BIP66: strict DER for ECDSA signatures only. Adds SCRIPT_VERIFY_DERSIG here —
    // not SCRIPT_VERIFY_STRICTENC or SCRIPT_VERIFY_LOW_S
    // (those are standardness / mempool policy; legacy blocks may contain high-S sigs).
    if activation.is_fork_active(ForkId::Bip66, height) {
        flags |= 0x04; // SCRIPT_VERIFY_DERSIG
    }
    if activation.is_fork_active(ForkId::Bip65, height) {
        flags |= 0x200; // CHECKLOCKTIMEVERIFY
    }
    // BIP112 (CSV): CHECKSEQUENCEVERIFY at CSV deployment height (mainnet 419328).
    if activation.is_fork_active(ForkId::Bip112, height) {
        flags |= 0x400; // SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
    }
    // BIP147 NULLDUMMY: enabled at SegWit deployment height (same as BIP147 on mainnet).
    if activation.is_fork_active(ForkId::Bip147, height) {
        flags |= 0x10; // SCRIPT_VERIFY_NULLDUMMY
    }
    #[cfg(feature = "ctv")]
    if activation.is_fork_active(ForkId::Ctv, height) {
        flags |= 0x80000000; // CHECK_TEMPLATE_VERIFY_HASH
    }

    flags
}

/// Convenience: base script flags from (height, network) when no context is available (e.g. mempool).
#[inline]
pub fn calculate_base_script_flags_for_block_network(
    height: u64,
    network: crate::types::Network,
) -> u32 {
    let table = ForkActivationTable::from_network(network);
    calculate_base_script_flags_for_block(height, &table)
}

/// True when any input witness stack in a block has a non-empty element.
///
/// Witness-serialized blocks attach a witness vector per input even for legacy spends;
/// those empty stacks must not alone trigger witness script rules (sort-merge step6 regression).
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.5", "HasNonEmptyInputWitness"))]
pub fn tx_has_nonempty_input_witness(per_input_witnesses: Option<&[Witness]>) -> bool {
    per_input_witnesses
        .map(|ws| ws.iter().any(|w| !is_witness_empty(w)))
        .unwrap_or(false)
}

/// Input to per-tx `SCRIPT_VERIFY_WITNESS` gating (Orange Paper §5.2.5 FlagCondition).
pub fn tx_requires_witness_script_flags(tx: &Transaction, has_witness: bool) -> bool {
    has_witness || is_segwit_transaction(tx)
}

/// Per-tx script flags (SegWit + Taproot). Add to base flags from `calculate_base_script_flags_for_block`.
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.5", "CalculateScriptFlags"))]
#[inline]
fn add_per_tx_script_flags(
    base_flags: u32,
    tx: &Transaction,
    has_witness: bool,
    height: u64,
    activation: &impl IsForkActive,
) -> u32 {
    let mut flags = base_flags;
    if activation.is_fork_active(ForkId::SegWit, height)
        && tx_requires_witness_script_flags(tx, has_witness)
    {
        flags |= 0x800;
    }
    flags
}

/// Calculate script verification flags for a transaction in a block (with activation context).
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.5", "CalculateScriptFlags"))]
pub(crate) fn calculate_script_flags_for_block(
    tx: &Transaction,
    has_witness: bool,
    height: u64,
    activation: &impl IsForkActive,
) -> u32 {
    let base = calculate_base_script_flags_for_block(height, activation);
    add_per_tx_script_flags(base, tx, has_witness, height, activation)
}

/// Convenience: script flags from (height, network) when no context is available (e.g. mempool, bench tools).
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.5", "CalculateScriptFlags"))]
pub fn calculate_script_flags_for_block_network(
    tx: &Transaction,
    has_witness: bool,
    height: u64,
    network: crate::types::Network,
) -> u32 {
    let table = ForkActivationTable::from_network(network);
    calculate_script_flags_for_block(tx, has_witness, height, &table)
}

/// Calculate script verification flags for a transaction in a block (with precomputed base flags).
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.5", "CalculateScriptFlags"))]
#[inline]
#[allow(dead_code)]
pub(crate) fn calculate_script_flags_for_block_with_base(
    tx: &Transaction,
    has_witness: bool,
    base_flags: u32,
    height: u64,
    activation: &impl IsForkActive,
) -> u32 {
    add_per_tx_script_flags(base_flags, tx, has_witness, height, activation)
}

// ---------------------------------------------------------------------------
// §5.2.6 Script flag exceptions (Orange Paper §5.2.6)
// ---------------------------------------------------------------------------

/// RPC / explorer 64-hex block id → canonical digest order used by `hash256(serialize(header))` here.
fn block_hash_from_rpc_hex(hex_str: &str) -> Hash {
    let mut bytes = hex::decode(hex_str).expect("valid 64-char block hash hex");
    assert_eq!(bytes.len(), 32);
    bytes.reverse();
    bytes.try_into().expect("length 32")
}

/// BIP16 exception block (mainnet). Uses `SCRIPT_VERIFY_NONE`.
static MAINNET_SCRIPT_FLAG_EXCEPTION_BIP16: LazyLock<Hash> = LazyLock::new(|| {
    block_hash_from_rpc_hex("00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22")
});
/// Taproot exception block (mainnet). Uses `SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS`.
static MAINNET_SCRIPT_FLAG_EXCEPTION_TAPROOT: LazyLock<Hash> = LazyLock::new(|| {
    block_hash_from_rpc_hex("0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad")
});
/// BIP16 exception block (testnet3). Uses `SCRIPT_VERIFY_NONE`.
static TESTNET_SCRIPT_FLAG_EXCEPTION_BIP16: LazyLock<Hash> = LazyLock::new(|| {
    block_hash_from_rpc_hex("00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105")
});

/// Consensus script-flag override for `block_hash` on `network`, if any (Orange Paper §5.2.6 table).
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.6", "ScriptFlagExceptions"))]
pub fn script_flag_exceptions_lookup(block_hash: &Hash, network: Network) -> Option<u32> {
    match network {
        Network::Mainnet => {
            if block_hash == &*MAINNET_SCRIPT_FLAG_EXCEPTION_BIP16 {
                Some(0)
            } else if block_hash == &*MAINNET_SCRIPT_FLAG_EXCEPTION_TAPROOT {
                Some(0x01 | 0x800) // SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS
            } else {
                None
            }
        }
        Network::Testnet => {
            if block_hash == &*TESTNET_SCRIPT_FLAG_EXCEPTION_BIP16 {
                Some(0)
            } else {
                None
            }
        }
        Network::Regtest | Network::Signet | Network::Testnet4 => None,
    }
}

/// Block-level script verify flags: start from `SCRIPT_VERIFY_P2SH |
/// SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT`, replace with the script-flag exception entry
/// when present, then OR buried deployments (BIP66, BIP65, CSV, BIP147-at-SegWit). Same **block-level**
/// bitmask is passed to script checks for every non-coinbase transaction.
///
/// This is **not** the Orange Paper §5.2.6 piecewise `GetBlockScriptFlags` (exception vs per-tx
/// `CalculateScriptFlags`); use [`get_block_script_flags`] for that formulation. `connect_block`
/// uses this function for production mainnet block validation.
pub fn get_block_script_verify_flags_core(
    block_hash: &Hash,
    height: u64,
    activation: &impl IsForkActive,
    network: Network,
) -> u32 {
    // Baseline matches Bitcoin Core GetBlockScriptFlags: P2SH | WITNESS | TAPROOT.
    // WITNESS_PUBKEYTYPE (0x8000) is standardness and is not set here.
    let mut flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT;
    if let Some(v) = script_flag_exceptions_lookup(block_hash, network) {
        flags = v;
    }
    if activation.is_fork_active(ForkId::Bip66, height) {
        flags |= 0x04; // SCRIPT_VERIFY_DERSIG
    }
    if activation.is_fork_active(ForkId::Bip65, height) {
        flags |= 0x200; // CHECKLOCKTIMEVERIFY
    }
    if activation.is_fork_active(ForkId::Bip112, height) {
        flags |= 0x400; // CHECKSEQUENCEVERIFY
    }
    if activation.is_fork_active(ForkId::Bip147, height) {
        flags |= 0x10; // NULLDUMMY (SegWit deployment)
    }
    #[cfg(feature = "ctv")]
    if activation.is_fork_active(ForkId::Ctv, height) {
        flags |= 0x80000000;
    }
    flags
}

/// Orange Paper §5.2.6: exception table wins when defined; otherwise per-tx `CalculateScriptFlags`.
///
/// **`connect_block`** uses [`get_block_script_verify_flags_core`] for the block-level mask;
/// this function is the Orange Paper §5.2.6 piecewise spec.
#[cfg_attr(feature = "spec-lock", spec_locked("5.2.6", "GetBlockScriptFlags"))]
pub fn get_block_script_flags(
    block_hash: &Hash,
    tx: &Transaction,
    has_witness: bool,
    height: u64,
    network: Network,
) -> u32 {
    if let Some(flags) = script_flag_exceptions_lookup(block_hash, network) {
        flags
    } else {
        calculate_script_flags_for_block_network(tx, has_witness, height, network)
    }
}

// ---------------------------------------------------------------------------
// Script-exec cache and overlay merge
// ---------------------------------------------------------------------------

/// Insert script exec cache keys for all txs in block (call when block validation passes).
#[cfg(all(feature = "production", feature = "rayon"))]
pub(super) fn insert_script_exec_cache_for_block(
    block: &Block,
    witnesses: &[Vec<Witness>],
    height: u64,
    context: &BlockValidationContext,
) {
    if !crate::script_exec_cache::enabled() {
        return;
    }
    let block_hash = crate::crypto::OptimizedSha256::new().hash256(
        &crate::serialization::block::serialize_block_header(&block.header),
    );
    let block_script_verify_flags =
        get_block_script_verify_flags_core(&block_hash, height, context, context.network);
    for (i, tx) in block.transactions.iter().enumerate() {
        if is_coinbase(tx) {
            continue;
        }
        let wits = witnesses.get(i).map(|w| w.as_slice()).unwrap_or(&[]);
        let witnesses_vec: Vec<_> = if wits.len() == tx.inputs.len() {
            wits.to_vec()
        } else {
            (0..tx.inputs.len()).map(|_| Vec::new()).collect()
        };
        let key =
            crate::script_exec_cache::compute_key(tx, &witnesses_vec, block_script_verify_flags);
        crate::script_exec_cache::insert(&key);
    }
}

/// Merge overlay changes into the UTXO set and update BIP30 index / undo log.
///
/// `skip_utxo_set_mutation`: when `true` (IBD path), the `utxo_set` is a per-block
/// scratch view that is discarded after this call. Skip all HashMap inserts/removes.
/// BIP30 still counts new coinbase outputs and decrements spent ones.
/// The non-IBD path (`false`) performs the full remove/insert cycle and builds the
/// undo log entry. `undo_log` must be `None` when `skip_utxo_set_mutation` is `true`.
#[cfg(feature = "production")]
pub(super) fn merge_overlay_changes_to_cache(
    additions: &FxHashMap<OutPoint, std::sync::Arc<UTXO>>,
    deletions: &FxHashSet<crate::utxo_overlay::UtxoDeletionKey>,
    utxo_set: &mut UtxoSet,
    mut bip30_index: Option<&mut crate::bip_validation::Bip30Index>,
    mut undo_log: Option<&mut crate::reorganization::BlockUndoLog>,
    skip_utxo_set_mutation: bool,
) {
    use crate::reorganization::UndoEntry;

    for del_key in deletions {
        let outpoint = crate::utxo_overlay::utxo_deletion_key_to_outpoint(del_key);
        if skip_utxo_set_mutation {
            // IBD fast path: utxo_set is discarded after this call.
            // Use get (no remove) solely for the BIP30 coinbase check.
            if let Some(idx) = bip30_index.as_deref_mut() {
                if utxo_set
                    .get(&outpoint)
                    .map(|arc| arc.is_coinbase)
                    .unwrap_or(false)
                {
                    if let std::collections::hash_map::Entry::Occupied(mut o) =
                        idx.entry(outpoint.hash)
                    {
                        *o.get_mut() = o.get().saturating_sub(1);
                        if *o.get() == 0 {
                            o.remove();
                        }
                    }
                }
            }
            // The IBD undo log is built by `undo_log_from_overlay`, not here.
        } else if let Some(arc) = utxo_set.remove(&outpoint) {
            if let Some(idx) = bip30_index.as_deref_mut() {
                if arc.is_coinbase {
                    if let std::collections::hash_map::Entry::Occupied(mut o) =
                        idx.entry(outpoint.hash)
                    {
                        *o.get_mut() = o.get().saturating_sub(1);
                        if *o.get() == 0 {
                            o.remove();
                        }
                    }
                }
            }
            if let Some(ref mut log) = undo_log {
                log.entries.push(UndoEntry {
                    outpoint,
                    previous_utxo: Some(arc),
                    new_utxo: None,
                });
            }
        }
    }

    for (outpoint, arc) in additions {
        if let Some(idx) = bip30_index.as_deref_mut() {
            if arc.is_coinbase {
                *idx.entry(outpoint.hash).or_insert(0) += 1;
            }
        }
        if !skip_utxo_set_mutation {
            if let Some(ref mut log) = undo_log {
                log.entries.push(UndoEntry {
                    outpoint: *outpoint,
                    previous_utxo: None,
                    new_utxo: Some(std::sync::Arc::clone(arc)),
                });
            }
            utxo_set.insert(*outpoint, std::sync::Arc::clone(arc));
        }
    }
}

/// Undo log for an overlay that was not merged into the scratch UTXO set.
///
/// Spent coins are read from `base`, the view the block was validated against.
/// A spent coin that `base` cannot return is an error. An empty log would let a
/// later disconnect succeed and restore nothing.
#[cfg(feature = "production")]
pub(super) fn undo_log_from_overlay(
    additions: &FxHashMap<OutPoint, std::sync::Arc<UTXO>>,
    deletions: &FxHashSet<crate::utxo_overlay::UtxoDeletionKey>,
    base: &dyn crate::utxo_overlay::UtxoLookup,
) -> crate::error::Result<crate::reorganization::BlockUndoLog> {
    use crate::reorganization::{BlockUndoLog, UndoEntry};

    let mut log = BlockUndoLog::new();
    log.entries.reserve(deletions.len() + additions.len());
    for del_key in deletions {
        let outpoint = crate::utxo_overlay::utxo_deletion_key_to_outpoint(del_key);
        let Some(prev) = base.get(&outpoint) else {
            return Err(crate::error::ConsensusError::BlockValidation(
                format!("undo log: spent coin {outpoint:?} is not in the base view").into(),
            ));
        };
        log.entries.push(UndoEntry {
            outpoint,
            previous_utxo: Some(std::sync::Arc::new(prev.clone())),
            new_utxo: None,
        });
    }
    for (outpoint, arc) in additions {
        let previous_utxo = base
            .get(outpoint)
            .map(|prev| std::sync::Arc::new(prev.clone()));
        log.entries.push(UndoEntry {
            outpoint: *outpoint,
            previous_utxo,
            new_utxo: Some(std::sync::Arc::clone(arc)),
        });
    }
    Ok(log)
}

/// Compute BIP143/precomputed sighash for the parallel script-check path. Uses local refs and specs Vecs
/// (dropped before return) so buf borrow ends.
#[cfg(all(feature = "production", feature = "rayon"))]
#[allow(dead_code)] // parallel script-check precompute hook (not yet wired in hot path)
pub(super) fn compute_bip143_and_precomp(
    tx: &Transaction,
    prevout_values: &[i64],
    script_pubkey_indices: &[(usize, usize)],
    script_pubkey_buffer: &[u8],
    has_witness: bool,
) -> (
    Option<crate::transaction_hash::Bip143PrecomputedHashes>,
    Vec<Option<[u8; 32]>>,
) {
    let buf = script_pubkey_buffer;
    let refs: Vec<&[u8]> = script_pubkey_indices
        .iter()
        .map(|&(s, l)| buf[s..s + l].as_ref())
        .collect();
    let refs: &[&[u8]] = &refs;
    if has_witness {
        let bip =
            crate::transaction_hash::Bip143PrecomputedHashes::compute(tx, prevout_values, refs);
        let mut precomp = vec![None; script_pubkey_indices.len()];
        let mut specs: Vec<(usize, u8, &[u8])> = Vec::new();
        for (j, &(s, l)) in script_pubkey_indices.iter().enumerate() {
            let spk = &buf[s..s + l];
            if spk.len() == 22 && spk[0] == OP_0 && spk[1] == PUSH_20_BYTES {
                let mut script_code = [0u8; 25];
                script_code[0] = OP_DUP;
                script_code[1] = OP_HASH160;
                script_code[2] = PUSH_20_BYTES;
                script_code[3..23].copy_from_slice(&spk[2..22]);
                script_code[23] = OP_EQUALVERIFY;
                script_code[24] = OP_CHECKSIG;
                let amount = prevout_values.get(j).copied().unwrap_or(0);
                if let Ok(h) = crate::transaction_hash::calculate_bip143_sighash(
                    tx,
                    j,
                    &script_code,
                    amount,
                    0x01,
                    Some(&bip),
                ) {
                    precomp[j] = Some(h);
                }
            } else if spk.len() == 23
                && spk[0] == OP_HASH160
                && spk[1] == PUSH_20_BYTES
                && spk[22] == OP_EQUAL
            {
                if let Some((sighash_byte, redeem)) =
                    crate::script::parse_p2sh_p2pkh_for_precompute(&tx.inputs[j].script_sig)
                {
                    specs.push((j, sighash_byte, redeem));
                }
            }
        }
        if !specs.is_empty() {
            if let Ok(hashes) = crate::transaction_hash::batch_compute_legacy_sighashes(
                tx,
                prevout_values,
                refs,
                &specs,
            ) {
                for (k, &(j, _, _)) in specs.iter().enumerate() {
                    precomp[j] = Some(hashes[k]);
                }
            }
        }
        (Some(bip), precomp)
    } else {
        let mut precomp = vec![None; script_pubkey_indices.len()];
        let mut specs: Vec<(usize, u8, &[u8])> = Vec::new();
        for (j, &(s, l)) in script_pubkey_indices.iter().enumerate() {
            let spk = &buf[s..s + l];
            if spk.len() == 25
                && spk[0] == OP_DUP
                && spk[1] == OP_HASH160
                && spk[2] == PUSH_20_BYTES
                && spk[23] == OP_EQUALVERIFY
                && spk[24] == OP_CHECKSIG
            {
                let script_sig = &tx.inputs[j].script_sig;
                if let Some((sig, _pubkey)) = crate::script::parse_p2pkh_script_sig(script_sig) {
                    if !sig.is_empty() {
                        specs.push((j, sig[sig.len() - 1], spk));
                    }
                }
            } else if spk.len() == 23
                && spk[0] == OP_HASH160
                && spk[1] == PUSH_20_BYTES
                && spk[22] == OP_EQUAL
            {
                if let Some((sighash_byte, redeem)) =
                    crate::script::parse_p2sh_p2pkh_for_precompute(&tx.inputs[j].script_sig)
                {
                    specs.push((j, sighash_byte, redeem));
                }
            }
        }
        if !specs.is_empty() {
            if let Ok(hashes) = crate::transaction_hash::batch_compute_legacy_sighashes(
                tx,
                prevout_values,
                refs,
                &specs,
            ) {
                for (k, &(j, _, _)) in specs.iter().enumerate() {
                    precomp[j] = Some(hashes[k]);
                }
            }
        }
        (None, precomp)
    }
}

#[cfg(test)]
mod script_flag_exceptions_tests {
    use super::{
        calculate_script_flags_for_block_network, get_block_script_flags,
        get_block_script_verify_flags_core, script_flag_exceptions_lookup,
    };
    use crate::activation::ForkActivationTable;
    use crate::crypto::OptimizedSha256;
    use crate::script::flags::{
        SCRIPT_VERIFY_P2SH, SCRIPT_VERIFY_TAPROOT, SCRIPT_VERIFY_WITNESS,
        SCRIPT_VERIFY_WITNESS_PUBKEYTYPE,
    };
    use crate::serialization::block::{deserialize_block_header, serialize_block_header};
    use crate::types::{Network, Transaction};

    fn hash_from_rpc_hex(hex_str: &str) -> [u8; 32] {
        let mut bytes = hex::decode(hex_str).unwrap();
        assert_eq!(bytes.len(), 32);
        bytes.reverse();
        bytes.try_into().unwrap()
    }

    #[test]
    fn mainnet_bip16_exception_zero() {
        let h =
            hash_from_rpc_hex("00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22");
        assert_eq!(script_flag_exceptions_lookup(&h, Network::Mainnet), Some(0));
    }

    #[test]
    fn mainnet_taproot_exception_p2sh_witness() {
        let h =
            hash_from_rpc_hex("0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad");
        assert_eq!(
            script_flag_exceptions_lookup(&h, Network::Mainnet),
            Some(0x01 | 0x800)
        );
    }

    #[test]
    fn testnet_bip16_exception_zero() {
        let h =
            hash_from_rpc_hex("00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105");
        assert_eq!(script_flag_exceptions_lookup(&h, Network::Testnet), Some(0));
        assert_eq!(script_flag_exceptions_lookup(&h, Network::Mainnet), None);
    }

    #[test]
    fn regtest_has_no_exceptions() {
        let h =
            hash_from_rpc_hex("00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22");
        assert_eq!(script_flag_exceptions_lookup(&h, Network::Regtest), None);
    }

    #[test]
    fn get_block_script_flags_uses_exception() {
        let h =
            hash_from_rpc_hex("00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22");
        let tx = Transaction {
            version: 1,
            inputs: Default::default(),
            outputs: Default::default(),
            lock_time: 0,
        };
        let flags = get_block_script_flags(&h, &tx, false, 1_000_000, Network::Mainnet);
        assert_eq!(flags, 0);
    }

    #[test]
    fn get_block_script_flags_falls_back_to_calculate() {
        let h = [7u8; 32];
        let tx = Transaction {
            version: 1,
            inputs: Default::default(),
            outputs: Default::default(),
            lock_time: 0,
        };
        assert_eq!(
            get_block_script_flags(&h, &tx, false, 100, Network::Mainnet),
            calculate_script_flags_for_block_network(&tx, false, 100, Network::Mainnet),
        );
    }

    #[test]
    fn genesis_rpc_hex_matches_hash256_of_header() {
        let genesis_block_hex = "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c010100000001000000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000";
        let bytes = hex::decode(genesis_block_hex).unwrap();
        let header = deserialize_block_header(&bytes[..80]).unwrap();
        let digest = OptimizedSha256::new().hash256(&serialize_block_header(&header));
        let expected =
            hash_from_rpc_hex("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
        assert_eq!(digest, expected);
    }

    #[test]
    fn core_block_flags_non_exception_includes_p2sh_witness_taproot_and_deployments() {
        let table = ForkActivationTable::from_network(Network::Mainnet);
        let h = [0xabu8; 32];
        let flags = get_block_script_verify_flags_core(&h, 800_000, &table, Network::Mainnet);
        // P2SH (0x1) | WITNESS (0x800) | TAPROOT (0x20000). WITNESS_PUBKEYTYPE is not a block flag.
        assert_eq!(
            flags
                & (SCRIPT_VERIFY_P2SH
                    | SCRIPT_VERIFY_WITNESS
                    | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
                    | SCRIPT_VERIFY_TAPROOT),
            SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT,
            "P2SH | WITNESS | TAPROOT baseline"
        );
        assert_eq!(flags & SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, 0);
        let pre_segwit = get_block_script_verify_flags_core(&h, 100, &table, Network::Mainnet);
        assert_ne!(
            pre_segwit & SCRIPT_VERIFY_WITNESS,
            0,
            "pre-segwit height still has WITNESS"
        );
        assert_ne!(flags & 0x04, 0, "DERSIG");
        assert_ne!(flags & 0x200, 0, "CLTV");
        assert_ne!(flags & 0x400, 0, "CSV");
        assert_ne!(flags & 0x10, 0, "NULLDUMMY");
    }

    #[test]
    fn core_block_flags_bip16_exception_orrs_buried_deployments() {
        let table = ForkActivationTable::from_network(Network::Mainnet);
        let h =
            hash_from_rpc_hex("00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22");
        assert_eq!(script_flag_exceptions_lookup(&h, Network::Mainnet), Some(0));
        let flags = get_block_script_verify_flags_core(&h, 800_000, &table, Network::Mainnet);
        let deployment_mask = 0x04 | 0x200 | 0x400 | 0x10;
        assert_eq!(flags & 0x8801, 0);
        assert_eq!(flags & deployment_mask, deployment_mask);
        assert_eq!(flags & 0x800, 0);
        assert_eq!(flags & 0x8000, 0);
        assert_eq!(flags & 0x01, 0);
    }

    #[test]
    fn core_block_flags_taproot_exception_orrs_deployments() {
        let table = ForkActivationTable::from_network(Network::Mainnet);
        let h =
            hash_from_rpc_hex("0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad");
        let flags = get_block_script_verify_flags_core(&h, 800_000, &table, Network::Mainnet);
        assert_eq!(flags & 0x8801, 0x801);
        assert_eq!(flags & 0x8000, 0);
        assert_ne!(flags & 0x800, 0);
        assert_ne!(flags & 0x04, 0);
    }
}

#[cfg(all(test, feature = "production"))]
mod replaced_output_undo_tests {
    use super::{merge_overlay_changes_to_cache, undo_log_from_overlay};
    use crate::types::{OutPoint, UTXO, UtxoSet};
    use rustc_hash::{FxHashMap, FxHashSet};
    use std::sync::Arc;

    #[test]
    fn addition_records_the_coin_it_replaces() {
        let outpoint = OutPoint {
            hash: [9u8; 32],
            index: 0,
        };
        let mut base = UtxoSet::default();
        base.insert(
            outpoint,
            Arc::new(UTXO {
                value: 50,
                script_pubkey: vec![0x51].into(),
                height: 1,
                is_coinbase: true,
            }),
        );
        let mut additions = FxHashMap::default();
        additions.insert(
            outpoint,
            Arc::new(UTXO {
                value: 50,
                script_pubkey: vec![0x52].into(),
                height: 91_842,
                is_coinbase: true,
            }),
        );
        let deletions = FxHashSet::default();
        let log = undo_log_from_overlay(&additions, &deletions, &base).unwrap();
        let previous = log.entries[0]
            .previous_utxo
            .as_ref()
            .expect("replaced coin is kept");
        assert_eq!(previous.height, 1);
        assert!(previous.is_coinbase);
        assert_eq!(log.entries[0].new_utxo.as_ref().unwrap().height, 91_842);

        let mut after = UtxoSet::default();
        after.insert(
            outpoint,
            Arc::clone(log.entries[0].new_utxo.as_ref().unwrap()),
        );
        after.remove(&outpoint);
        after.insert(outpoint, Arc::clone(previous));
        assert_eq!(after.get(&outpoint).unwrap().height, 1);
    }

    #[test]
    fn ibd_merge_counts_a_new_coinbase_output() {
        let txid = [0x11u8; 32];
        let outpoint = OutPoint {
            hash: txid,
            index: 0,
        };
        let mut additions = FxHashMap::default();
        additions.insert(
            outpoint,
            Arc::new(UTXO {
                value: 50,
                script_pubkey: vec![0x51].into(),
                height: 1,
                is_coinbase: true,
            }),
        );
        let deletions = FxHashSet::default();
        let mut index = crate::bip_validation::Bip30Index::default();
        let mut utxo_set = UtxoSet::default();
        merge_overlay_changes_to_cache(
            &additions,
            &deletions,
            &mut utxo_set,
            Some(&mut index),
            None,
            true,
        );
        assert!(utxo_set.is_empty(), "the IBD scratch set stays unchanged");
        assert_eq!(index.get(&txid).copied(), Some(1));
    }
}