khadhroony-solana-project/crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/continuity.rs

// file: crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/continuity.rs
// version: 4

fn network() -> std::option::Option<ksp_store_lib::RawNetworkId> {
    return match ksp_store_lib::RawNetworkId::new("mainnet") {
        std::result::Result::Ok(value) => std::option::Option::Some(value),
        std::result::Result::Err(_) => std::option::Option::None,
    };
}

fn exact_scope(family: &'static str, fingerprint_byte: u8) -> crate::RawTransactionIngestCoverageScope {
    return crate::RawTransactionIngestCoverageScope::exact_source_scope(family, [fingerprint_byte; 32]);
}

fn capability(
    source_key_byte: u8,
    commitment: ksp_onchain_transport_lib::SolanaCommitment,
    scope: crate::RawTransactionIngestCoverageScope,
) -> std::option::Option<crate::RawTransactionIngestContinuityCapabilityDescriptor> {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return std::option::Option::None,
    };
    return match crate::RawTransactionIngestContinuityCapabilityDescriptor::new(
        [source_key_byte; 32],
        network,
        commitment,
        scope,
        true,
        false,
        false,
        true,
        false,
        false,
    ) {
        std::result::Result::Ok(value) => std::option::Option::Some(value),
        std::result::Result::Err(_) => std::option::Option::None,
    };
}

fn gap(
    gap_id: u64,
    source_key_byte: u8,
    start_slot: u64,
    end_slot: u64,
    state: super::RawTransactionIngestGapState,
) -> std::option::Option<super::RawTransactionIngestGap> {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return std::option::Option::None,
    };
    let range = match super::RawTransactionIngestGapRange::new(start_slot, end_slot) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    return std::option::Option::Some(super::RawTransactionIngestGap {
        commitment: ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        coverage_requirement: exact_scope("standard_logs", 9),
        gap_id: super::RawTransactionIngestGapId(gap_id),
        network,
        range,
        reason: super::RawTransactionIngestGapReason::WebSocketReconnect,
        source_key: [source_key_byte; 32],
        state,
    });
}

#[test]
fn pre_002_repair_bounds_are_exact_and_run_local() {
    assert_eq!(super::MAX_RAW_TRANSACTION_INGEST_OPEN_REPAIR_GAPS, 64);
    assert_eq!(super::MAX_RAW_TRANSACTION_INGEST_REPAIR_ACTIVE_GAPS, 1);
    assert_eq!(super::MAX_RAW_TRANSACTION_INGEST_REPAIR_BLOCK_FETCH_IN_FLIGHT, 4);
    assert_eq!(super::MAX_RAW_TRANSACTION_INGEST_REPAIR_DISCOVERY_WINDOW_SLOTS, 512);
    assert_eq!(super::MAX_RAW_TRANSACTION_INGEST_REPAIR_RANGE_SLOTS, 4_096);
    return;
}

#[test]
fn pre_002_gap_range_is_inclusive_bounded_and_overflow_safe() {
    assert!(super::RawTransactionIngestGapRange::new(10, 9).is_err());
    assert!(super::RawTransactionIngestGapRange::new(10, 10 + super::MAX_RAW_TRANSACTION_INGEST_REPAIR_RANGE_SLOTS - 1).is_ok());
    assert!(super::RawTransactionIngestGapRange::new(10, 10 + super::MAX_RAW_TRANSACTION_INGEST_REPAIR_RANGE_SLOTS).is_err());
    assert!(super::RawTransactionIngestGapRange::new(u64::MAX, u64::MAX).is_ok());
    return;
}

#[test]
fn pre_002_gap_range_overlap_and_adjacency_are_explicit() {
    let first = match super::RawTransactionIngestGapRange::new(100, 109) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected first range failure: {error}"),
    };
    let overlap = match super::RawTransactionIngestGapRange::new(105, 115) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected overlap range failure: {error}"),
    };
    let adjacent = match super::RawTransactionIngestGapRange::new(110, 120) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected adjacent range failure: {error}"),
    };
    let separate = match super::RawTransactionIngestGapRange::new(111, 120) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected separate range failure: {error}"),
    };
    assert!(first.overlaps_or_is_adjacent(overlap));
    assert!(first.overlaps_or_is_adjacent(adjacent));
    assert!(!first.overlaps_or_is_adjacent(separate));
    let merged = first.try_merge(adjacent);
    assert!(matches!(merged, std::result::Result::Ok(std::option::Option::Some(value)) if value.start_slot() == 100 && value.end_slot() == 120));
    return;
}

#[test]
fn pre_002_target_coverage_deduplicates_exact_scopes_without_cross_commitment_broadening() {
    let first = match capability(1, ksp_onchain_transport_lib::SolanaCommitment::Confirmed, exact_scope("standard_logs", 7)) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("first capability fixture unavailable"),
    };
    let second = match capability(2, ksp_onchain_transport_lib::SolanaCommitment::Confirmed, exact_scope("standard_logs", 7)) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("second capability fixture unavailable"),
    };
    let finalized_full =
        match capability(3, ksp_onchain_transport_lib::SolanaCommitment::Finalized, crate::RawTransactionIngestCoverageScope::full_ledger_transactions()) {
            std::option::Option::Some(value) => value,
            std::option::Option::None => panic!("full capability fixture unavailable"),
        };
    let contracts = match crate::RawTransactionIngestContinuityContracts::new(std::vec![first, second, finalized_full]) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("continuity contracts fixture failed: {error}"),
    };
    assert_eq!(contracts.capabilities.len(), 3);
    assert_eq!(contracts.target_coverage.requirements.len(), 2);
    assert!(contracts.target_coverage.requirements.iter().any(|requirement| {
        return requirement.commitment == ksp_onchain_transport_lib::SolanaCommitment::Confirmed && requirement.scope == exact_scope("standard_logs", 7);
    }));
    assert!(contracts.target_coverage.requirements.iter().any(|requirement| {
        return requirement.commitment == ksp_onchain_transport_lib::SolanaCommitment::Finalized
            && requirement.scope == crate::RawTransactionIngestCoverageScope::full_ledger_transactions();
    }));
    return;
}

#[test]
fn pre_002_full_ledger_scope_subsumes_only_same_commitment_targets() {
    let exact = match capability(1, ksp_onchain_transport_lib::SolanaCommitment::Confirmed, exact_scope("helius_transaction", 4)) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("exact capability fixture unavailable"),
    };
    let full = match capability(2, ksp_onchain_transport_lib::SolanaCommitment::Confirmed, crate::RawTransactionIngestCoverageScope::full_ledger_transactions())
    {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("full capability fixture unavailable"),
    };
    let contracts = match crate::RawTransactionIngestContinuityContracts::new(std::vec![exact, full]) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("continuity contracts fixture failed: {error}"),
    };
    assert_eq!(contracts.target_coverage.requirements.len(), 1);
    assert_eq!(contracts.target_coverage.requirements[0].scope, crate::RawTransactionIngestCoverageScope::full_ledger_transactions());
    assert_eq!(contracts.target_coverage.requirements[0].commitment, ksp_onchain_transport_lib::SolanaCommitment::Confirmed);
    return;
}

#[test]
fn pre_002_known_references_can_never_be_configured_target_coverage() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("network fixture unavailable"),
    };
    let result = crate::RawTransactionIngestContinuityCapabilityDescriptor::new(
        [1_u8; 32],
        network,
        ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        crate::RawTransactionIngestCoverageScope::KnownReferences([2_u8; 32]),
        true,
        false,
        false,
        true,
        false,
        false,
    );
    assert!(result.is_err());
    return;
}

#[test]
fn pre_002_gap_ledger_rejects_coalescible_open_ranges_and_active_overflow() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("network fixture unavailable"),
    };
    let first = match gap(1, 1, 100, 109, super::RawTransactionIngestGapState::Pending) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("first gap fixture unavailable"),
    };
    let adjacent = match gap(2, 1, 110, 120, super::RawTransactionIngestGapState::Pending) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("adjacent gap fixture unavailable"),
    };
    let adjacent_ledger = super::RawTransactionIngestGapLedger { gaps: std::vec![first, adjacent], network: network.clone(), next_gap_id: 3 };
    assert!(adjacent_ledger.validate_invariants().is_err());
    let first_active = match gap(1, 1, 100, 109, super::RawTransactionIngestGapState::Repairing) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("first active gap fixture unavailable"),
    };
    let second_active = match gap(2, 2, 200, 209, super::RawTransactionIngestGapState::Repairing) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("second active gap fixture unavailable"),
    };
    let active_ledger = super::RawTransactionIngestGapLedger { gaps: std::vec![first_active, second_active], network, next_gap_id: 3 };
    assert!(active_ledger.validate_invariants().is_err());
    return;
}

#[test]
fn pre_002_gap_ledger_enforces_open_gap_bound_and_next_id_monotonicity() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("network fixture unavailable"),
    };
    let mut gaps = std::vec::Vec::new();
    for index in 0..=super::MAX_RAW_TRANSACTION_INGEST_OPEN_REPAIR_GAPS {
        let gap_id = (index as u64) + 1;
        let slot = (index as u64) * 2;
        let gap = match gap(gap_id, 1, slot, slot, super::RawTransactionIngestGapState::Pending) {
            std::option::Option::Some(value) => value,
            std::option::Option::None => panic!("gap fixture unavailable"),
        };
        gaps.push(gap);
    }
    let ledger = super::RawTransactionIngestGapLedger { gaps, network: network.clone(), next_gap_id: 66 };
    assert!(ledger.validate_invariants().is_err());
    let single = match gap(7, 1, 100, 100, super::RawTransactionIngestGapState::Unresolved) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("single gap fixture unavailable"),
    };
    let stale_next = super::RawTransactionIngestGapLedger { gaps: std::vec![single], network, next_gap_id: 7 };
    assert!(stale_next.validate_invariants().is_err());
    return;
}

#[test]
fn pre_003_websocket_incident_anchor_is_inclusive_monotone_and_bounded() {
    let mut anchor = match crate::RawTransactionIngestWebSocketIncidentAnchor::new(100, 1, 0, true, false) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected anchor failure: {error}"),
    };
    assert_eq!(anchor.start_slot(), 100);
    assert_eq!(anchor.end_slot(), std::option::Option::None);
    assert!(anchor.saw_reconnect());
    assert!(!anchor.saw_overflow());
    assert!(anchor.extend(2, 1, true, true).is_ok());
    assert!(anchor.saw_reconnect());
    assert!(anchor.saw_overflow());
    assert!(anchor.extend(1, 1, false, false).is_err());
    assert!(anchor.close_at(100 + super::MAX_RAW_TRANSACTION_INGEST_REPAIR_RANGE_SLOTS - 1).is_ok());
    assert_eq!(anchor.end_slot(), std::option::Option::Some(100 + super::MAX_RAW_TRANSACTION_INGEST_REPAIR_RANGE_SLOTS - 1));
    assert!(anchor.extend(3, 1, true, false).is_err());
    return;
}

#[test]
fn pre_003_websocket_incident_anchor_rejects_missing_reason_reversal_and_oversize() {
    assert!(crate::RawTransactionIngestWebSocketIncidentAnchor::new(100, 0, 0, false, false).is_err());
    let mut reversed = match crate::RawTransactionIngestWebSocketIncidentAnchor::new(100, 0, 1, false, true) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected overflow anchor failure: {error}"),
    };
    assert!(reversed.close_at(99).is_err());
    let mut oversized = match crate::RawTransactionIngestWebSocketIncidentAnchor::new(100, 1, 0, true, false) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected oversize anchor fixture failure: {error}"),
    };
    assert!(oversized.close_at(100 + super::MAX_RAW_TRANSACTION_INGEST_REPAIR_RANGE_SLOTS).is_err());
    return;
}

#[test]
fn pre_005_scope_relations_are_exact_superset_and_cross_family_conservative() {
    let exact = exact_scope("standard_logs", 7);
    let same = exact_scope("standard_logs", 7);
    let different_filter = exact_scope("standard_logs", 8);
    let different_family = exact_scope("helius_transaction", 7);
    let full = crate::RawTransactionIngestCoverageScope::full_ledger_transactions();
    assert_eq!(exact.relation_to(&same), std::option::Option::Some(super::RawTransactionIngestCoverageRelation::Exact));
    assert_eq!(full.relation_to(&exact), std::option::Option::Some(super::RawTransactionIngestCoverageRelation::Superset));
    assert_eq!(full.relation_to(&full), std::option::Option::Some(super::RawTransactionIngestCoverageRelation::Exact));
    assert!(exact.relation_to(&full).is_none());
    assert!(exact.relation_to(&different_filter).is_none());
    assert!(exact.relation_to(&different_family).is_none());
    assert!(crate::RawTransactionIngestCoverageScope::KnownReferences([7_u8; 32]).relation_to(&exact).is_none());
    return;
}

#[test]
fn pre_005_coverage_epoch_requires_distinct_source_same_commitment_and_full_range() {
    let target_requirement = super::RawTransactionIngestCoverageRequirement {
        commitment: ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        scope: exact_scope("standard_logs", 9),
    };
    let gap = match super::RawTransactionIngestGapRange::new(100, 110) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected gap fixture failure: {error}"),
    };
    let full_range = match super::RawTransactionIngestCoverageRange::new(90, 120) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected coverage range failure: {error}"),
    };
    let partial_range = match super::RawTransactionIngestCoverageRange::new(100, 109) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected partial coverage range failure: {error}"),
    };
    let exact_epoch = match super::RawTransactionIngestCoverageEpoch::new(
        1,
        [2_u8; 32],
        ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        exact_scope("standard_logs", 9),
        full_range,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected exact epoch failure: {error}"),
    };
    let full_epoch = match super::RawTransactionIngestCoverageEpoch::new(
        2,
        [3_u8; 32],
        ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        crate::RawTransactionIngestCoverageScope::full_ledger_transactions(),
        full_range,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected full epoch failure: {error}"),
    };
    let partial_epoch = match super::RawTransactionIngestCoverageEpoch::new(
        3,
        [4_u8; 32],
        ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        crate::RawTransactionIngestCoverageScope::full_ledger_transactions(),
        partial_range,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected partial epoch failure: {error}"),
    };
    let finalized_epoch = match super::RawTransactionIngestCoverageEpoch::new(
        4,
        [5_u8; 32],
        ksp_onchain_transport_lib::SolanaCommitment::Finalized,
        crate::RawTransactionIngestCoverageScope::full_ledger_transactions(),
        full_range,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected finalized epoch failure: {error}"),
    };
    assert_eq!(
        exact_epoch.relation_to_requirement([1_u8; 32], &target_requirement, gap),
        std::option::Option::Some(super::RawTransactionIngestCoverageRelation::Exact),
    );
    assert_eq!(
        full_epoch.relation_to_requirement([1_u8; 32], &target_requirement, gap),
        std::option::Option::Some(super::RawTransactionIngestCoverageRelation::Superset),
    );
    assert!(exact_epoch.relation_to_requirement([2_u8; 32], &target_requirement, gap).is_none());
    assert!(partial_epoch.relation_to_requirement([1_u8; 32], &target_requirement, gap).is_none());
    assert!(finalized_epoch.relation_to_requirement([1_u8; 32], &target_requirement, gap).is_none());
    return;
}

#[test]
fn pre_005_cross_family_exact_scopes_never_become_redundant_by_fingerprint_alone() {
    let target_requirement = super::RawTransactionIngestCoverageRequirement {
        commitment: ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        scope: exact_scope("standard_logs", 11),
    };
    let gap = match super::RawTransactionIngestGapRange::new(500, 510) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected gap fixture failure: {error}"),
    };
    let range = match super::RawTransactionIngestCoverageRange::new(490, 520) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected coverage range failure: {error}"),
    };
    let epoch = match super::RawTransactionIngestCoverageEpoch::new(
        1,
        [2_u8; 32],
        ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        exact_scope("helius_transaction", 11),
        range,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected epoch failure: {error}"),
    };
    assert!(epoch.relation_to_requirement([1_u8; 32], &target_requirement, gap).is_none());
    return;
}

#[test]
fn pre_005_coverage_epoch_ledger_is_bounded_monotone_and_capability_bound() {
    assert_eq!(super::MAX_RAW_TRANSACTION_INGEST_COVERAGE_EPOCHS, 256);
    let matching = match capability(2, ksp_onchain_transport_lib::SolanaCommitment::Confirmed, exact_scope("standard_logs", 5)) {
        std::option::Option::Some(value) => value,
        std::option::Option::None => panic!("matching capability fixture unavailable"),
    };
    let range = match super::RawTransactionIngestCoverageRange::new(100, 200) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected coverage range failure: {error}"),
    };
    let epoch = match super::RawTransactionIngestCoverageEpoch::new(
        1,
        [2_u8; 32],
        ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        exact_scope("standard_logs", 5),
        range,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected coverage epoch failure: {error}"),
    };
    let valid = super::RawTransactionIngestCoverageEpochLedger { epochs: std::vec![epoch.clone()], next_epoch_id: 2 };
    assert!(valid.validate_invariants(std::slice::from_ref(&matching)).is_ok());
    let requirement = super::RawTransactionIngestCoverageRequirement {
        commitment: ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
        scope: exact_scope("standard_logs", 5),
    };
    let gap = match super::RawTransactionIngestGapRange::new(120, 130) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => panic!("unexpected ledger gap failure: {error}"),
    };
    assert_eq!(
        valid.redundant_relation_for_gap([1_u8; 32], &requirement, gap),
        std::option::Option::Some(super::RawTransactionIngestCoverageRelation::Exact),
    );
    assert!(valid.redundant_relation_for_gap([2_u8; 32], &requirement, gap).is_none());
    let stale = super::RawTransactionIngestCoverageEpochLedger { epochs: std::vec![epoch.clone()], next_epoch_id: 1 };
    assert!(stale.validate_invariants(std::slice::from_ref(&matching)).is_err());
    let unknown = super::RawTransactionIngestCoverageEpochLedger { epochs: std::vec![epoch], next_epoch_id: 2 };
    assert!(unknown.validate_invariants(&[]).is_err());
    let mut too_many = std::vec::Vec::new();
    for index in 0..=super::MAX_RAW_TRANSACTION_INGEST_COVERAGE_EPOCHS {
        let epoch_id = (index as u64) + 1;
        let epoch = match super::RawTransactionIngestCoverageEpoch::new(
            epoch_id,
            [2_u8; 32],
            ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
            exact_scope("standard_logs", 5),
            range,
        ) {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => panic!("unexpected bounded epoch failure: {error}"),
        };
        too_many.push(epoch);
    }
    let overflow =
        super::RawTransactionIngestCoverageEpochLedger { epochs: too_many, next_epoch_id: (super::MAX_RAW_TRANSACTION_INGEST_COVERAGE_EPOCHS as u64) + 2 };
    assert!(overflow.validate_invariants(std::slice::from_ref(&matching)).is_err());
    return;
}