Sasedev/khadhroony-solana-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.3.3-pre.005

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-08-30 12:42:50 +02:00
parent 917e602a87
commit 66a3926adb
14 changed files with 1106 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs
// version: 1
// version: 2
fn network() -> ksp_store_api::RawNetworkId {
return match ksp_store_api::RawNetworkId::new("devnet") {
@@ -181,3 +181,175 @@ fn pre_004_wrong_network_is_rejected_by_the_private_pre_io_guard() {
assert_eq!(rejected.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::WrongNetwork));
return;
}
fn raw_transaction(signature_byte: u8, payload_bytes: &[u8], content_hash_byte: u8) -> ksp_store_api::RawTransaction {
let reference = ksp_store_api::RawTransactionReference::new(network(), ksp_store_api::RawTransactionSignature::new([signature_byte; 64]));
let format_id = match ksp_store_api::RawFormatId::new("ksp.raw.transaction") {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid test format rejected: {error:?}"),
};
let payload = match ksp_store_api::RawPayload::try_new(
format_id,
1,
payload_bytes.to_vec().into_boxed_slice(),
ksp_store_api::RawContentHash::new([content_hash_byte; 32]),
) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid test payload rejected: {error:?}"),
};
return ksp_store_api::RawTransaction::new(reference, 42, std::option::Option::None, payload);
}
fn observation(reference: ksp_store_api::RawTransactionReference, key_byte: u8, provider: &str) -> ksp_store_api::RawTransactionObservation {
let provider = match ksp_store_api::RawProvenanceCode::new(provider) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid test provider rejected: {error:?}"),
};
let protocol = match ksp_store_api::RawProvenanceCode::new("solana-ws") {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid test protocol rejected: {error:?}"),
};
let method = match ksp_store_api::RawProvenanceCode::new("transactionSubscribe") {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid test method rejected: {error:?}"),
};
let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1_700_000_000_000) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid test timestamp rejected: {error:?}"),
};
let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Live, received_at);
return ksp_store_api::RawTransactionObservation::new(ksp_store_api::RawObservationKey::new([key_byte; 32]), reference, provenance);
}
#[test]
fn pre_005_atomic_acquisition_pre_io_guard_requires_backend_network_and_exact_reference() {
let backend_network = network();
let raw_transaction = raw_transaction(1, &[1, 2, 3], 7);
let matching = observation(raw_transaction.reference().clone(), 3, "publicnode");
assert!(super::ensure_acquisition_inputs(&backend_network, &raw_transaction, &matching).is_ok());
let other_reference = ksp_store_api::RawTransactionReference::new(backend_network.clone(), ksp_store_api::RawTransactionSignature::new([2; 64]));
let mismatched = observation(other_reference, 4, "publicnode");
let mismatch = super::ensure_acquisition_inputs(&backend_network, &raw_transaction, &mismatched);
assert_eq!(mismatch.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::Conflict));
let other_network = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid alternate network rejected: {error:?}"),
};
let foreign_reference = ksp_store_api::RawTransactionReference::new(other_network, ksp_store_api::RawTransactionSignature::new([1; 64]));
let foreign = observation(foreign_reference, 5, "publicnode");
let wrong_network = super::ensure_acquisition_inputs(&backend_network, &raw_transaction, &foreign);
assert_eq!(wrong_network.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::WrongNetwork));
return;
}
#[test]
fn pre_005_existing_full_content_requires_exact_payload_equality_not_hash_only() {
let network = network();
let incoming = raw_transaction(9, &[1, 2, 3, 4], 7);
let matching = super::compare_existing_transaction(&network, transaction_row("full"), &incoming);
assert!(matching.is_err(), "fixture intentionally differs in slot/content and must conflict");
let mut exact_row = transaction_row("full");
exact_row.signature = vec![9; 64];
exact_row.slot_text = "42".to_owned();
exact_row.block_time_unix_millis = std::option::Option::None;
exact_row.format_version = 1;
exact_row.payload = std::option::Option::Some(vec![1, 2, 3, 4]);
let exact = super::compare_existing_transaction(&network, exact_row, &incoming);
assert!(matches!(exact, std::result::Result::Ok(super::ExistingTransactionMatch::Active)));
let mut same_hash_different_bytes = transaction_row("full");
same_hash_different_bytes.signature = vec![9; 64];
same_hash_different_bytes.slot_text = "42".to_owned();
same_hash_different_bytes.block_time_unix_millis = std::option::Option::None;
same_hash_different_bytes.format_version = 1;
same_hash_different_bytes.payload = std::option::Option::Some(vec![9, 9, 9, 9]);
let conflict = super::compare_existing_transaction(&network, same_hash_different_bytes, &incoming);
assert_eq!(conflict.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::Conflict));
return;
}
#[test]
fn pre_005_purged_tombstone_matches_only_retained_identity_metadata() {
let network = network();
let incoming = raw_transaction(9, &[1, 2, 3, 4], 7);
let mut purged = transaction_row("purged");
purged.signature = vec![9; 64];
purged.slot_text = "42".to_owned();
purged.block_time_unix_millis = std::option::Option::None;
purged.format_version = 1;
purged.payload = std::option::Option::None;
purged.archive_payload = std::option::Option::None;
let compatible = super::compare_existing_transaction(&network, purged, &incoming);
assert!(matches!(compatible, std::result::Result::Ok(super::ExistingTransactionMatch::Purged)));
let mut divergent = transaction_row("purged");
divergent.signature = vec![9; 64];
divergent.slot_text = "42".to_owned();
divergent.block_time_unix_millis = std::option::Option::None;
divergent.format_version = 1;
divergent.content_hash = vec![8; 32];
divergent.payload = std::option::Option::None;
divergent.archive_payload = std::option::Option::None;
let conflict = super::compare_existing_transaction(&network, divergent, &incoming);
assert_eq!(conflict.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::Conflict));
return;
}
#[test]
fn pre_005_observation_idempotence_compares_reference_and_complete_provenance() {
let incoming_transaction = raw_transaction(8, &[1, 2, 3], 4);
let incoming = observation(incoming_transaction.reference().clone(), 3, "publicnode");
let matching_row = super::RawObservationDbRow {
acquisition_method: "transactionSubscribe".to_owned(),
capture_session_id: std::option::Option::None,
commitment: std::option::Option::None,
endpoint_id: std::option::Option::None,
filter_id: std::option::Option::None,
observation_key: vec![3; 32],
observed_at_unix_millis: std::option::Option::None,
origin: "live".to_owned(),
protocol: "solana-ws".to_owned(),
provider: "publicnode".to_owned(),
received_at_unix_millis: 1_700_000_000_000,
source_payload_hash: std::option::Option::None,
source_payload_size_bytes: std::option::Option::None,
transaction_signature: vec![8; 64],
};
let matching = super::decode_raw_observation_row(&network(), matching_row);
let matching = match matching {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid matching observation rejected: {error:?}"),
};
assert!(matching.eq(&incoming));
let divergent_row = super::RawObservationDbRow {
acquisition_method: "transactionSubscribe".to_owned(),
capture_session_id: std::option::Option::None,
commitment: std::option::Option::None,
endpoint_id: std::option::Option::None,
filter_id: std::option::Option::None,
observation_key: vec![3; 32],
observed_at_unix_millis: std::option::Option::None,
origin: "live".to_owned(),
protocol: "solana-ws".to_owned(),
provider: "another-provider".to_owned(),
received_at_unix_millis: 1_700_000_000_000,
source_payload_hash: std::option::Option::None,
source_payload_size_bytes: std::option::Option::None,
transaction_signature: vec![8; 64],
};
let divergent = super::decode_raw_observation_row(&network(), divergent_row);
let divergent = match divergent {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => panic!("valid divergent observation rejected: {error:?}"),
};
assert!(!divergent.eq(&incoming));
return;
}
#[test]
fn pre_005_observation_origin_encoding_is_exact_and_static() {
assert_eq!(super::encode_origin(ksp_store_api::RawAcquisitionOrigin::Backfill), std::result::Result::Ok("backfill"));
assert_eq!(super::encode_origin(ksp_store_api::RawAcquisitionOrigin::Import), std::result::Result::Ok("import"));
assert_eq!(super::encode_origin(ksp_store_api::RawAcquisitionOrigin::Live), std::result::Result::Ok("live"));
assert_eq!(super::encode_origin(ksp_store_api::RawAcquisitionOrigin::Repair), std::result::Result::Ok("repair"));
assert_eq!(super::encode_origin(ksp_store_api::RawAcquisitionOrigin::Replay), std::result::Result::Ok("replay"));
return;
}