blvm-consensus 0.1.10

//! Block Header Validation Verification Tests
//!
//! Tests to verify BLLVM's block header validation matches consensus exactly.
//! Block header validation is consensus-critical - differences = chain split.
//!
//! Consensus checks:
//! - Version >= 1
//! - Timestamp != 0 (and not too far in future)
//! - Bits != 0
//! - Merkle root != 0
//! - Proof of work: hash < target

use blvm_consensus::pow::{check_proof_of_work, expand_target};
use blvm_consensus::types::*;
use sha2::{Digest, Sha256};

/// Create a valid block header
fn create_valid_header() -> BlockHeader {
    BlockHeader {
        version: 1,
        prev_block_hash: [1; 32],
        merkle_root: [2; 32],
        timestamp: 1231006505,
        bits: 0x1d00ffff, // Genesis difficulty
        nonce: 0,
    }
}

/// Test block header validation: valid header
///
/// Consensus: Valid header should pass all checks
#[test]
fn test_block_header_valid() {
    let header = create_valid_header();

    // Verify all fields are valid
    assert!(header.version >= 1, "Version should be >= 1");
    assert_ne!(header.timestamp, 0, "Timestamp should not be zero");
    assert_ne!(header.bits, 0, "Bits should not be zero");
    assert_ne!(
        header.merkle_root, [0u8; 32],
        "Merkle root should not be zero"
    );
}

/// Test block header validation: invalid version (0)
///
/// Consensus rejects: version < 1
#[test]
fn test_block_header_invalid_version_zero() {
    let mut header = create_valid_header();
    header.version = 0;

    // Version 0 should be invalid
    assert_eq!(header.version, 0, "Version should be 0");
}

/// Test block header validation: invalid timestamp (0)
///
/// Consensus rejects: timestamp == 0
#[test]
fn test_block_header_invalid_timestamp_zero() {
    let mut header = create_valid_header();
    header.timestamp = 0;

    // Timestamp 0 should be invalid
    assert_eq!(header.timestamp, 0, "Timestamp should be 0");
}

/// Test block header validation: invalid bits (0)
///
/// Consensus rejects: bits == 0
#[test]
fn test_block_header_invalid_bits_zero() {
    let mut header = create_valid_header();
    header.bits = 0;

    // Bits 0 should be invalid
    assert_eq!(header.bits, 0, "Bits should be 0");
}

/// Test block header validation: invalid merkle root (all zeros)
///
/// Consensus rejects: merkle_root == [0; 32]
#[test]
fn test_block_header_invalid_merkle_root_zero() {
    let mut header = create_valid_header();
    header.merkle_root = [0u8; 32];

    // Merkle root all zeros should be invalid
    assert_eq!(
        header.merkle_root, [0u8; 32],
        "Merkle root should be all zeros"
    );
}

/// Test proof of work verification: valid PoW
///
/// Consensus: hash < target should pass
#[test]
fn test_proof_of_work_valid() {
    // Create a header with valid proof of work
    // For testing, we'll use genesis difficulty which is very easy
    let header = create_valid_header();

    // Verify PoW check doesn't panic
    let result = check_proof_of_work(&header);
    assert!(
        result.is_ok() || result.is_err(),
        "PoW check should complete"
    );
}

/// Test proof of work verification: hash >= target (invalid)
///
/// Consensus rejects: hash >= target
#[test]
fn test_proof_of_work_invalid_hash_too_large() {
    // Create a header where hash would be >= target
    // This is difficult to test without actually mining, but we can verify
    // the function exists and works
    let header = create_valid_header();

    // The check should complete (may pass or fail depending on nonce)
    let result = check_proof_of_work(&header);
    assert!(
        result.is_ok() || result.is_err(),
        "PoW check should complete"
    );
}

/// Test proof of work: target expansion matches header bits
///
/// Consensus: target = expand_target(bits)
#[test]
fn test_proof_of_work_target_expansion() {
    let header = create_valid_header();

    // Expand target from bits
    let result = expand_target(header.bits);
    assert!(result.is_ok(), "Target expansion should succeed");

    let target = result.unwrap();
    // Target should be non-zero for valid bits
    // (We can't easily check if it's zero without accessing private methods)
}

/// Test block header: version boundary (1)
///
/// Consensus: version >= 1 is valid
#[test]
fn test_block_header_version_minimum() {
    let mut header = create_valid_header();
    header.version = 1; // Minimum valid version

    assert_eq!(header.version, 1, "Version should be 1 (minimum)");
}

/// Test block header: timestamp reasonable bounds
///
/// Consensus: timestamp should be reasonable (not too far in future)
#[test]
fn test_block_header_timestamp_reasonable() {
    let header = create_valid_header();

    // Timestamp should be reasonable (not zero, not in distant future)
    assert!(header.timestamp > 0, "Timestamp should be positive");
    // Genesis timestamp is 1231006505, so any reasonable timestamp should be >= that
    assert!(
        header.timestamp >= 1231006505 || header.timestamp < 2000000000,
        "Timestamp should be in reasonable range"
    );
}

/// Test block header: bits valid range
///
/// Consensus: bits should be in valid range (not 0, not too large)
#[test]
fn test_block_header_bits_valid_range() {
    let header = create_valid_header();

    // Bits should be non-zero and in valid range
    assert_ne!(header.bits, 0, "Bits should not be zero");
    // Genesis bits = 0x1d00ffff, which is valid
    assert!(
        header.bits >= 0x03000000 && header.bits <= 0x1d00ffff,
        "Bits should be in valid range"
    );
}

/// Test block header: merkle root hash format
///
/// Consensus: merkle root must be valid 32-byte hash
#[test]
fn test_block_header_merkle_root_format() {
    let header = create_valid_header();

    // Merkle root should be 32 bytes (array length)
    assert_eq!(
        header.merkle_root.len(),
        32,
        "Merkle root should be 32 bytes"
    );
    assert_ne!(
        header.merkle_root, [0u8; 32],
        "Merkle root should not be all zeros"
    );
}

/// Test proof of work: header serialization
///
/// Consensus: PoW uses double SHA256 of serialized header
#[test]
fn test_proof_of_work_header_serialization() {
    let header = create_valid_header();

    // Verify header can be serialized (needed for PoW)
    // Serialize header to bytes
    let mut header_bytes = Vec::new();
    header_bytes.extend_from_slice(&(header.version as i32).to_le_bytes());
    header_bytes.extend_from_slice(&header.prev_block_hash);
    header_bytes.extend_from_slice(&header.merkle_root);
    header_bytes.extend_from_slice(&(header.timestamp as u32).to_le_bytes());
    header_bytes.extend_from_slice(&(header.bits as u32).to_le_bytes());
    header_bytes.extend_from_slice(&(header.nonce as u32).to_le_bytes());

    // Header should be 80 bytes (standard block header size)
    assert_eq!(header_bytes.len(), 80, "Block header should be 80 bytes");

    // Double SHA256 should work
    let hash1 = Sha256::digest(&header_bytes);
    let hash2 = Sha256::digest(hash1);

    assert_eq!(hash2.len(), 32, "Double SHA256 should produce 32-byte hash");
}