v0.3.14-pre.005

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/continuity.rs
-// version: 3
+// version: 4
 
 fn network() -> std::option::Option<ksp_store_lib::RawNetworkId> {
     return match ksp_store_lib::RawNetworkId::new("mainnet") {
@@ -275,3 +275,181 @@ fn pre_003_websocket_incident_anchor_rejects_missing_reason_reversal_and_oversiz
     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;
+}