356 lines
19 KiB
Rust
356 lines
19 KiB
Rust
// file: crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs
|
|
// version: 2
|
|
|
|
fn network() -> ksp_store_api::RawNetworkId {
|
|
return match ksp_store_api::RawNetworkId::new("devnet") {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => panic!("valid test network rejected: {error:?}"),
|
|
};
|
|
}
|
|
|
|
fn transaction_row(state: &str) -> super::RawTransactionDbRow {
|
|
return super::RawTransactionDbRow {
|
|
archive_payload: std::option::Option::None,
|
|
block_time_unix_millis: std::option::Option::Some(1_700_000_000_000),
|
|
content_hash: vec![7; 32],
|
|
format_id: "ksp.raw.transaction".to_owned(),
|
|
format_version: i64::from(u32::MAX),
|
|
payload: std::option::Option::Some(vec![1, 2, 3, 4]),
|
|
retention_state: state.to_owned(),
|
|
signature: vec![9; 64],
|
|
slot_text: u64::MAX.to_string(),
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_full_and_archived_rows_round_trip_without_integer_narrowing() {
|
|
let network = network();
|
|
let full = super::decode_raw_transaction_row(&network, transaction_row("full"));
|
|
let full = match full {
|
|
std::result::Result::Ok(std::option::Option::Some(value)) => value,
|
|
other => panic!("valid full row rejected: {other:?}"),
|
|
};
|
|
assert_eq!(full.slot(), u64::MAX);
|
|
assert_eq!(full.block_time().map(|value| return value.unix_millis()), std::option::Option::Some(1_700_000_000_000));
|
|
assert_eq!(full.payload().format_version(), u32::MAX);
|
|
assert_eq!(full.payload().bytes(), &[1, 2, 3, 4]);
|
|
assert_eq!(full.reference().network().as_str(), "devnet");
|
|
assert_eq!(full.reference().signature().as_bytes(), &[9; 64]);
|
|
let mut archived_row = transaction_row("archived");
|
|
archived_row.payload = std::option::Option::None;
|
|
archived_row.archive_payload = std::option::Option::Some(vec![5, 6, 7]);
|
|
let archived = super::decode_raw_transaction_row(&network, archived_row);
|
|
let archived = match archived {
|
|
std::result::Result::Ok(std::option::Option::Some(value)) => value,
|
|
other => panic!("valid archived row rejected: {other:?}"),
|
|
};
|
|
assert_eq!(archived.slot(), u64::MAX);
|
|
assert_eq!(archived.payload().bytes(), &[5, 6, 7]);
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_purged_get_returns_none_and_rejects_payload_or_block_time_residue() {
|
|
let network = network();
|
|
let mut purged_row = transaction_row("purged");
|
|
purged_row.payload = std::option::Option::None;
|
|
purged_row.archive_payload = std::option::Option::None;
|
|
purged_row.block_time_unix_millis = std::option::Option::None;
|
|
let purged = super::decode_raw_transaction_row(&network, purged_row);
|
|
assert!(matches!(purged, std::result::Result::Ok(std::option::Option::None)));
|
|
let mut malformed = transaction_row("purged");
|
|
malformed.archive_payload = std::option::Option::None;
|
|
malformed.block_time_unix_millis = std::option::Option::None;
|
|
let malformed = super::decode_raw_transaction_row(&network, malformed);
|
|
assert_eq!(malformed.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_observation_row_reconstructs_complete_safe_provenance() {
|
|
let network = network();
|
|
let row = super::RawObservationDbRow {
|
|
acquisition_method: "transactionSubscribe".to_owned(),
|
|
capture_session_id: std::option::Option::Some("capture-1".to_owned()),
|
|
commitment: std::option::Option::Some("confirmed".to_owned()),
|
|
endpoint_id: std::option::Option::Some("publicnode-devnet".to_owned()),
|
|
filter_id: std::option::Option::Some("filter-1".to_owned()),
|
|
observation_key: vec![3; 32],
|
|
observed_at_unix_millis: std::option::Option::Some(1_699_999_999_000),
|
|
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::Some(vec![4; 32]),
|
|
source_payload_size_bytes: std::option::Option::Some(64 * 1024 * 1024),
|
|
transaction_signature: vec![8; 64],
|
|
};
|
|
let decoded = super::decode_raw_observation_row(&network, row);
|
|
let decoded = match decoded {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => panic!("valid observation row rejected: {error:?}"),
|
|
};
|
|
assert_eq!(decoded.observation_key().as_bytes(), &[3; 32]);
|
|
assert_eq!(decoded.transaction().network().as_str(), "devnet");
|
|
assert_eq!(decoded.transaction().signature().as_bytes(), &[8; 64]);
|
|
assert_eq!(decoded.provenance().provider().as_str(), "publicnode");
|
|
assert_eq!(decoded.provenance().protocol().as_str(), "solana-ws");
|
|
assert_eq!(decoded.provenance().acquisition_method().as_str(), "transactionSubscribe");
|
|
assert_eq!(decoded.provenance().capture_session_id().map(|value| return value.as_str()), std::option::Option::Some("capture-1"));
|
|
assert_eq!(decoded.provenance().commitment().map(|value| return value.as_str()), std::option::Option::Some("confirmed"));
|
|
assert_eq!(decoded.provenance().endpoint_id().map(|value| return value.as_str()), std::option::Option::Some("publicnode-devnet"));
|
|
assert_eq!(decoded.provenance().filter_id().map(|value| return value.as_str()), std::option::Option::Some("filter-1"));
|
|
assert_eq!(decoded.provenance().observed_at().map(|value| return value.unix_millis()), std::option::Option::Some(1_699_999_999_000));
|
|
assert_eq!(decoded.provenance().received_at().unix_millis(), 1_700_000_000_000);
|
|
assert_eq!(decoded.provenance().source_payload_hash().map(|value| return *value.as_bytes()), std::option::Option::Some([4; 32]));
|
|
assert_eq!(decoded.provenance().source_payload_size_bytes(), std::option::Option::Some(64 * 1024 * 1024));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_hostile_rows_map_to_static_data_invalid_without_echoing_values() {
|
|
let network = network();
|
|
let mut oversized_slot = transaction_row("full");
|
|
oversized_slot.slot_text = "18446744073709551616".to_owned();
|
|
let slot_error = super::decode_raw_transaction_row(&network, oversized_slot).err();
|
|
assert_eq!(slot_error.as_ref().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
|
|
assert_eq!(slot_error.as_ref().map(|value| return value.phase()), std::option::Option::Some("raw_transaction_slot"));
|
|
let mut bad_hash = transaction_row("full");
|
|
bad_hash.content_hash = vec![1; 31];
|
|
let hash_error = super::decode_raw_transaction_row(&network, bad_hash).err();
|
|
assert_eq!(hash_error.as_ref().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
|
|
assert!(!format!("{hash_error:?}").contains("18446744073709551616"));
|
|
let bad_origin = super::decode_origin("https://hostile.invalid/secret");
|
|
let origin_error = bad_origin.err();
|
|
assert_eq!(origin_error.as_ref().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
|
|
assert!(!format!("{origin_error:?}").contains("hostile.invalid"));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_retention_and_tombstone_decoding_is_exact() {
|
|
assert!(matches!(super::decode_retention_state("full"), std::result::Result::Ok(ksp_store_api::RawRetentionState::Full)));
|
|
assert!(matches!(super::decode_retention_state("archived"), std::result::Result::Ok(ksp_store_api::RawRetentionState::Archived)));
|
|
assert!(matches!(super::decode_retention_state("purged"), std::result::Result::Ok(ksp_store_api::RawRetentionState::Purged)));
|
|
assert_eq!(
|
|
super::decode_retention_state("compacted").err().map(|value| return value.kind()),
|
|
std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid),
|
|
);
|
|
let network = network();
|
|
let row = super::RawTombstoneDbRow {
|
|
block_time_unix_millis: std::option::Option::None,
|
|
content_hash: vec![6; 32],
|
|
format_id: "ksp.raw.transaction".to_owned(),
|
|
format_version: i64::from(u32::MAX),
|
|
retention_state: "purged".to_owned(),
|
|
signature: vec![2; 64],
|
|
slot_text: u64::MAX.to_string(),
|
|
};
|
|
let tombstone = super::decode_raw_tombstone_row(&network, row);
|
|
let tombstone = match tombstone {
|
|
std::result::Result::Ok(std::option::Option::Some(value)) => value,
|
|
other => panic!("valid tombstone row rejected: {other:?}"),
|
|
};
|
|
assert_eq!(tombstone.slot(), u64::MAX);
|
|
assert_eq!(tombstone.format_version(), u32::MAX);
|
|
assert_eq!(tombstone.content_hash().as_bytes(), &[6; 32]);
|
|
assert_eq!(tombstone.reference().signature().as_bytes(), &[2; 64]);
|
|
let malformed = super::RawTombstoneDbRow {
|
|
block_time_unix_millis: std::option::Option::Some(1),
|
|
content_hash: vec![6; 32],
|
|
format_id: "ksp.raw.transaction".to_owned(),
|
|
format_version: 1,
|
|
retention_state: "purged".to_owned(),
|
|
signature: vec![2; 64],
|
|
slot_text: "1".to_owned(),
|
|
};
|
|
let malformed = super::decode_raw_tombstone_row(&network, malformed);
|
|
assert_eq!(malformed.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_wrong_network_is_rejected_by_the_private_pre_io_guard() {
|
|
let backend_network = network();
|
|
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 reference = ksp_store_api::RawTransactionReference::new(other_network, ksp_store_api::RawTransactionSignature::new([1; 64]));
|
|
let rejected = super::ensure_network(&backend_network, &reference, "test_network");
|
|
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;
|
|
}
|