khadhroony-solana-project/crates/ksp-store-api/unit_tests/model/raw_transaction.rs

// file: crates/ksp-store-api/unit_tests/model/raw_transaction.rs
// version: 3

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

fn payload() -> std::option::Option<crate::RawPayload> {
    let format = match crate::RawFormatId::new("ksp.solana.raw_transaction".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    return match crate::RawPayload::try_new(
        format,
        1,
        b"canonical transaction including logs".to_vec().into_boxed_slice(),
        crate::RawContentHash::new([5_u8; 32]),
    ) {
        std::result::Result::Ok(value) => std::option::Option::Some(value),
        std::result::Result::Err(_) => std::option::Option::None,
    };
}

fn provenance() -> std::option::Option<crate::RawAcquisitionProvenance> {
    let provider = match crate::RawProvenanceCode::new("publicnode".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let protocol = match crate::RawProvenanceCode::new("yellowstone_grpc".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let method = match crate::RawProvenanceCode::new("transactions".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let received_at = match crate::RawTimestamp::from_unix_millis(1_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    return std::option::Option::Some(crate::RawAcquisitionProvenance::new(provider, protocol, method, crate::RawAcquisitionOrigin::Backfill, received_at));
}

#[test]
fn raw_transaction_identity_is_network_plus_signature_and_payload_remains_whole() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let payload = match payload() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let signature = crate::RawTransactionSignature::new([9_u8; 64]);
    let reference = crate::RawTransactionReference::new(network, signature);
    let transaction = crate::RawTransaction::new(reference, 42, std::option::Option::None, payload);
    assert_eq!(transaction.reference().network().as_str(), "mainnet");
    assert_eq!(transaction.reference().signature(), signature);
    assert_eq!(transaction.slot(), 42);
    assert!(transaction.block_time().is_none());
    assert_eq!(transaction.payload().bytes(), b"canonical transaction including logs");
    return;
}

#[test]
fn transaction_observation_is_separate_from_canonical_raw_payload() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let provenance = match provenance() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let signature = crate::RawTransactionSignature::new([11_u8; 64]);
    let reference = crate::RawTransactionReference::new(network, signature);
    let observation = crate::RawTransactionObservation::new(crate::RawObservationKey::new([12_u8; 32]), reference, provenance);
    assert_eq!(observation.transaction().signature(), signature);
    assert_eq!(observation.observation_key().as_bytes(), &[12_u8; 32]);
    assert_eq!(observation.provenance().provider().as_str(), "publicnode");
    return;
}

#[test]
fn transaction_variant_identity_is_non_zero_and_keeps_transaction_scope() {
    assert!(crate::RawTransactionVariantId::try_new(0).is_err());
    let variant_id = match crate::RawTransactionVariantId::try_new(7) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let transaction = crate::RawTransactionReference::new(network, crate::RawTransactionSignature::new([13_u8; 64]));
    let variant = crate::RawTransactionVariantReference::new(transaction, variant_id);
    assert_eq!(variant.variant_id().get(), 7);
    assert_eq!(variant.transaction().network().as_str(), "mainnet");
    assert_eq!(crate::RawTransactionVariantOrigin::Native.code(), "native");
    assert_eq!(crate::RawTransactionVariantOrigin::Synthetic.code(), "synthetic");
    return;
}

#[test]
fn transaction_variant_relation_reason_pairs_are_validated() {
    let exact = crate::RawTransactionVariantComparison::try_new(
        crate::RawTransactionVariantRelation::Exact,
        crate::RawTransactionVariantRelationReason::ExactCanonicalContent,
    );
    assert!(exact.is_ok());
    let invalid = crate::RawTransactionVariantComparison::try_new(
        crate::RawTransactionVariantRelation::Exact,
        crate::RawTransactionVariantRelationReason::IncomingLogMessagesTruncated,
    );
    assert!(invalid.is_err());
    let conflict = crate::RawTransactionVariantComparison::try_new(
        crate::RawTransactionVariantRelation::Conflict,
        crate::RawTransactionVariantRelationReason::ContentHashCollision,
    );
    assert!(conflict.is_ok());
    let incomparable = crate::RawTransactionVariantComparison::try_new(
        crate::RawTransactionVariantRelation::Incomparable,
        crate::RawTransactionVariantRelationReason::PayloadFormatMismatch,
    );
    assert!(incomparable.is_ok());
    return;
}

#[test]
fn transaction_variant_codes_and_outcomes_are_stable_backend_neutral_contracts() {
    assert_eq!(crate::RawTransactionVariantRelation::CompatibleLessComplete.code(), "compatible_less_complete");
    assert_eq!(crate::RawTransactionVariantRelationReason::IncomingLogMessagesTruncated.code(), "incoming_log_messages_truncated");
    assert_eq!(crate::RawTransactionVariantRelationReason::ContentHashCollision.code(), "content_hash_collision");
    assert_eq!(crate::RawTransactionConflictStatus::Open.code(), "open");
    assert_eq!(crate::RawTransactionConflictStatus::Resolved.code(), "resolved");
    assert_ne!(crate::RawTransactionVariantWriteOutcome::InsertedCanonical, crate::RawTransactionVariantWriteOutcome::ObservedExact);
    assert_ne!(crate::RawTransactionVariantWriteOutcome::QuarantinedConflict, crate::RawTransactionVariantWriteOutcome::PromotedCompatibleMoreComplete);
    return;
}