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

0.3.16-pre.004

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-09-21 17:53:13 +02:00
parent ec053c98ab
commit 19712aa7a6
9 changed files with 622 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
crates/ksp-store-postgres-lib/tests/postgres_foundation_live.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-store-postgres-lib/tests/postgres_foundation_live.rs
// version: 4
// version: 5
#![warn(missing_docs)]
#![deny(unreachable_pub)]
@@ -15,7 +15,11 @@
const LIVE_BOOTSTRAP_SQL: &str = include_str!("../migrations/v000_bootstrap/tables/001_ksp_store_schema_migrations.sql");
const LIVE_BROKEN_CHECKSUM_A: &str = "0000000000000000000000000000000000000000000000000000000000000000";
const LIVE_BROKEN_CHECKSUM_B: &str = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
const LIVE_MANAGED_SCHEMA_DROP_SQL: &str = r#"DROP TABLE IF EXISTS ksp_raw_transaction_observations;
const LIVE_MANAGED_SCHEMA_DROP_SQL: &str = r#"DROP TABLE IF EXISTS ksp_raw_transaction_conflicts;
DROP TABLE IF EXISTS ksp_raw_transaction_observation_variants;
DROP TABLE IF EXISTS ksp_raw_transaction_canonical_selectors;
DROP TABLE IF EXISTS ksp_raw_transaction_variants;
DROP TABLE IF EXISTS ksp_raw_transaction_observations;
DROP TABLE IF EXISTS ksp_raw_transaction_archive_payloads;
DROP TABLE IF EXISTS ksp_raw_transactions;
DROP TABLE IF EXISTS ksp_store_identity;
@@ -28,7 +32,11 @@ const LIVE_MANAGED_SCHEMA_EXISTS_SQL: &str = r#"SELECT EXISTS (
'ksp_store_identity',
'ksp_raw_transactions',
'ksp_raw_transaction_observations',
'ksp_raw_transaction_archive_payloads'
'ksp_raw_transaction_archive_payloads',
'ksp_raw_transaction_variants',
'ksp_raw_transaction_canonical_selectors',
'ksp_raw_transaction_observation_variants',
'ksp_raw_transaction_conflicts'
)
AND table_type = 'BASE TABLE'
)"#;
@@ -153,7 +161,7 @@ async fn run_foundation_scenario(admin: &mut tokio_postgres::Client, uri: &str,
}
*owns_schema = true;
let initial_health = initial.health().await;
if !initial_health.is_ready() || initial_health.migration_version() != std::option::Option::Some(2) || initial_health.pending_migration_count() != 0 {
if !initial_health.is_ready() || initial_health.migration_version() != std::option::Option::Some(3) || initial_health.pending_migration_count() != 0 {
return std::result::Result::Err(LiveFailure::new("initial_health"));
}
let initial_close = close_backend(initial).await;
@@ -167,7 +175,7 @@ async fn run_foundation_scenario(admin: &mut tokio_postgres::Client, uri: &str,
};
let idempotent_health = idempotent.health().await;
if !idempotent_health.is_ready()
|| idempotent_health.migration_version() != std::option::Option::Some(2)
|| idempotent_health.migration_version() != std::option::Option::Some(3)
|| idempotent_health.pending_migration_count() != 0
{
return std::result::Result::Err(LiveFailure::new("idempotent_health"));
@@ -250,7 +258,7 @@ async fn run_foundation_scenario(admin: &mut tokio_postgres::Client, uri: &str,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let final_health = final_backend.health().await;
if !final_health.is_ready() || final_health.migration_version() != std::option::Option::Some(2) || final_health.pending_migration_count() != 0 {
if !final_health.is_ready() || final_health.migration_version() != std::option::Option::Some(3) || final_health.pending_migration_count() != 0 {
return std::result::Result::Err(LiveFailure::new("final_health"));
}
return close_backend(final_backend).await;

16
crates/ksp-store-postgres-lib/tests/postgres_raw_account_live.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-store-postgres-lib/tests/postgres_raw_account_live.rs
// version: 2
// version: 3
#![warn(missing_docs)]
#![deny(unreachable_pub)]
@@ -20,7 +20,11 @@ const LIVE_ACCOUNT_STATE_EXISTS_SQL: &str =
"SELECT EXISTS (SELECT 1 FROM ksp_raw_account_states WHERE pubkey = $1 AND slot = $2::TEXT::NUMERIC AND state_hash = $3)";
const LIVE_CANCEL_WAIT: std::time::Duration = std::time::Duration::from_millis(300);
const LIVE_LOCK_ACCOUNT_OBSERVATION_SQL: &str = "SELECT observation_key FROM ksp_raw_account_observations WHERE observation_key = $1 FOR UPDATE";
const LIVE_MANAGED_SCHEMA_DROP_SQL: &str = r#"DROP TABLE IF EXISTS ksp_raw_account_observations;
const LIVE_MANAGED_SCHEMA_DROP_SQL: &str = r#"DROP TABLE IF EXISTS ksp_raw_transaction_conflicts;
DROP TABLE IF EXISTS ksp_raw_transaction_observation_variants;
DROP TABLE IF EXISTS ksp_raw_transaction_canonical_selectors;
DROP TABLE IF EXISTS ksp_raw_transaction_variants;
DROP TABLE IF EXISTS ksp_raw_account_observations;
DROP TABLE IF EXISTS ksp_raw_account_states;
DROP TABLE IF EXISTS ksp_raw_transaction_observations;
DROP TABLE IF EXISTS ksp_raw_transaction_archive_payloads;
@@ -36,6 +40,10 @@ const LIVE_MANAGED_SCHEMA_EXISTS_SQL: &str = r#"SELECT EXISTS (
'ksp_raw_transactions',
'ksp_raw_transaction_observations',
'ksp_raw_transaction_archive_payloads',
'ksp_raw_transaction_variants',
'ksp_raw_transaction_canonical_selectors',
'ksp_raw_transaction_observation_variants',
'ksp_raw_transaction_conflicts',
'ksp_raw_account_states',
'ksp_raw_account_observations'
)
@@ -152,7 +160,7 @@ async fn run_raw_account_scenario(admin: &mut tokio_postgres::Client, uri: &str,
};
*owns_schema = true;
let initial_health = initial.health().await;
if !initial_health.is_ready() || initial_health.migration_version() != std::option::Option::Some(2) || initial_health.pending_migration_count() != 0 {
if !initial_health.is_ready() || initial_health.migration_version() != std::option::Option::Some(3) || initial_health.pending_migration_count() != 0 {
return std::result::Result::Err(LiveFailure::new("initial_health"));
}
let wrong_network_result = open_backend_result(uri, "testnet", true, true).await;
@@ -211,7 +219,7 @@ async fn run_raw_account_scenario(admin: &mut tokio_postgres::Client, uri: &str,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let reopened_health = reopened.health().await;
if !reopened_health.is_ready() || reopened_health.migration_version() != std::option::Option::Some(2) {
if !reopened_health.is_ready() || reopened_health.migration_version() != std::option::Option::Some(3) {
return std::result::Result::Err(LiveFailure::new("reopen_health"));
}
let reference = match account_reference(10, 100, 10) {

50
crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs
// version: 7
// version: 9
#![warn(missing_docs)]
#![deny(unreachable_pub)]
@@ -18,7 +18,11 @@ const LIVE_INDEX_EXISTS_SQL: &str = r#"SELECT EXISTS (
AND indexname = 'ix_ksp_raw_transactions_slot_signature'
)"#;
const LIVE_LOCK_OBSERVATION_SQL: &str = "SELECT observation_key FROM ksp_raw_transaction_observations WHERE observation_key = $1 FOR UPDATE";
const LIVE_MANAGED_SCHEMA_DROP_SQL: &str = r#"DROP TABLE IF EXISTS ksp_raw_account_observations;
const LIVE_MANAGED_SCHEMA_DROP_SQL: &str = r#"DROP TABLE IF EXISTS ksp_raw_transaction_conflicts;
DROP TABLE IF EXISTS ksp_raw_transaction_observation_variants;
DROP TABLE IF EXISTS ksp_raw_transaction_canonical_selectors;
DROP TABLE IF EXISTS ksp_raw_transaction_variants;
DROP TABLE IF EXISTS ksp_raw_account_observations;
DROP TABLE IF EXISTS ksp_raw_account_states;
DROP TABLE IF EXISTS ksp_raw_transaction_observations;
DROP TABLE IF EXISTS ksp_raw_transaction_archive_payloads;
@@ -34,6 +38,10 @@ const LIVE_MANAGED_SCHEMA_EXISTS_SQL: &str = r#"SELECT EXISTS (
'ksp_raw_transactions',
'ksp_raw_transaction_observations',
'ksp_raw_transaction_archive_payloads',
'ksp_raw_transaction_variants',
'ksp_raw_transaction_canonical_selectors',
'ksp_raw_transaction_observation_variants',
'ksp_raw_transaction_conflicts',
'ksp_raw_account_states',
'ksp_raw_account_observations'
)
@@ -42,6 +50,7 @@ const LIVE_MANAGED_SCHEMA_EXISTS_SQL: &str = r#"SELECT EXISTS (
const LIVE_MAX_URI_BYTES: usize = 4_096;
const LIVE_OBSERVATION_EXISTS_SQL: &str = "SELECT EXISTS (SELECT 1 FROM ksp_raw_transaction_observations WHERE observation_key = $1)";
const LIVE_TRANSACTION_EXISTS_SQL: &str = "SELECT EXISTS (SELECT 1 FROM ksp_raw_transactions WHERE signature = $1)";
const LIVE_VARIANT_IDEMPOTENCE_SQL: &str = "SELECT (SELECT COUNT(*) = 1 FROM ksp_raw_transaction_variants WHERE transaction_signature = $1) AND (SELECT COUNT(*) = 1 FROM ksp_raw_transaction_canonical_selectors WHERE transaction_signature = $1) AND (SELECT COUNT(*) = 1 FROM ksp_raw_transaction_observation_variants WHERE transaction_signature = $1) AND EXISTS (SELECT 1 FROM ksp_raw_transaction_observation_variants AS mapping INNER JOIN ksp_raw_transaction_canonical_selectors AS selector ON selector.transaction_signature = mapping.transaction_signature AND selector.canonical_variant_id = mapping.variant_id WHERE mapping.observation_key = $2 AND mapping.transaction_signature = $1)";
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct LiveFailure {
@@ -157,7 +166,7 @@ async fn run_raw_transaction_scenario(admin: &mut tokio_postgres::Client, uri: &
};
*owns_schema = true;
let initial_health = initial.health().await;
if !initial_health.is_ready() || initial_health.migration_version() != std::option::Option::Some(2) || initial_health.pending_migration_count() != 0 {
if !initial_health.is_ready() || initial_health.migration_version() != std::option::Option::Some(3) || initial_health.pending_migration_count() != 0 {
return std::result::Result::Err(LiveFailure::new("initial_health"));
}
let wrong_network_result = open_backend_result(uri, "testnet", true, true).await;
@@ -197,7 +206,7 @@ async fn run_raw_transaction_scenario(admin: &mut tokio_postgres::Client, uri: &
if let std::result::Result::Err(error) = backend_close {
return std::result::Result::Err(error);
}
let identical_result = prove_concurrent_identical_insert(uri).await;
let identical_result = prove_concurrent_identical_insert(admin, uri).await;
if let std::result::Result::Err(error) = identical_result {
return std::result::Result::Err(error);
}
@@ -219,7 +228,7 @@ async fn run_raw_transaction_scenario(admin: &mut tokio_postgres::Client, uri: &
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let reopened_health = reopened.health().await;
if !reopened_health.is_ready() || reopened_health.migration_version() != std::option::Option::Some(2) {
if !reopened_health.is_ready() || reopened_health.migration_version() != std::option::Option::Some(3) {
return std::result::Result::Err(LiveFailure::new("reopen_health"));
}
let reference_result = raw_reference(10);
@@ -361,7 +370,7 @@ async fn prove_additional_observation_and_atomic_rollback(backend: &ksp_store_po
return std::result::Result::Ok(());
}
async fn prove_concurrent_identical_insert(uri: &str) -> std::result::Result<(), LiveFailure> {
async fn prove_concurrent_identical_insert(admin: &tokio_postgres::Client, uri: &str) -> std::result::Result<(), LiveFailure> {
let first = tokio::spawn(persist_once(uri.to_owned(), 20, 2_000, 20, 20));
let second = tokio::spawn(persist_once(uri.to_owned(), 20, 2_000, 20, 20));
let first_result = match joined_persist(first.await, "concurrent_identical_first") {
@@ -378,6 +387,17 @@ async fn prove_concurrent_identical_insert(uri: &str) -> std::result::Result<(),
if inserted != 1 || already != 1 {
return std::result::Result::Err(LiveFailure::new("concurrent_identical_outcome"));
}
let reference = match raw_reference(20) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
let key = ksp_store_api::RawObservationKey::new([20; 32]);
let projection_result = variant_projection_is_exact(admin, &reference, &key).await;
match projection_result {
std::result::Result::Ok(true) => {},
std::result::Result::Ok(false) => return std::result::Result::Err(LiveFailure::new("concurrent_identical_variant_projection")),
std::result::Result::Err(error) => return std::result::Result::Err(error),
}
return std::result::Result::Ok(());
}
@@ -1256,3 +1276,21 @@ async fn observation_exists(client: &tokio_postgres::Client, key: &ksp_store_api
std::result::Result::Err(_) => std::result::Result::Err(LiveFailure::new("observation_exists_decode")),
};
}
async fn variant_projection_is_exact(
client: &tokio_postgres::Client,
reference: &ksp_store_api::RawTransactionReference,
key: &ksp_store_api::RawObservationKey,
) -> std::result::Result<bool, LiveFailure> {
let signature = reference.signature();
let signature_bytes: &[u8] = signature.as_bytes();
let key_bytes: &[u8] = key.as_bytes();
let row = match client.query_one(LIVE_VARIANT_IDEMPOTENCE_SQL, &[&signature_bytes, &key_bytes]).await {
std::result::Result::Ok(value) => value,
std::result::Result::Err(_) => return std::result::Result::Err(LiveFailure::new("variant_projection_probe")),
};
return match row.try_get::<usize, bool>(0) {
std::result::Result::Ok(value) => std::result::Result::Ok(value),
std::result::Result::Err(_) => std::result::Result::Err(LiveFailure::new("variant_projection_decode")),
};
}

68
crates/ksp-store-postgres-lib/tests/v003_variant_persistence.rs Normal file
View File

@@ -0,0 +1,68 @@
// file: crates/ksp-store-postgres-lib/tests/v003_variant_persistence.rs
// version: 1
#![warn(missing_docs)]
#![deny(unreachable_pub)]
#![forbid(unsafe_code)]
//! Static completeness canaries for the first V003 variant-aware PostgreSQL write slice.
#[test]
fn v0_3_16_pre_004_acquisition_orders_identity_lock_bootstrap_observation_and_variant_link_atomically() {
let source = include_str!("../src/raw_transaction.rs");
let start = source.find("pub(crate) async fn persist_raw_transaction_acquisition(");
let end = source.find("pub(crate) async fn record_raw_transaction_observation(");
let (start, end) = match (start, end) {
(std::option::Option::Some(start), std::option::Option::Some(end)) if start < end => (start, end),
_ => panic!("pre.004 acquisition function markers are missing"),
};
let body = &source[start..end];
let lock = body.find("load_locked_transaction_row");
let bootstrap = body.find("ensure_v003_transaction_variant_bootstrap");
let compare = body.find("compare_existing_transaction");
let observation = body.find("persist_observation_row");
let link = body.find("persist_transaction_variant_link");
assert!(matches!((lock, bootstrap, compare), (Some(lock), Some(bootstrap), Some(compare)) if lock < bootstrap && bootstrap < compare));
assert!(matches!((observation, link), (Some(observation), Some(link)) if observation < link));
assert!(body.contains("sql_transaction.commit().await"));
return;
}
#[test]
fn v0_3_16_pre_004_native_variant_reuse_is_exact_and_hash_is_only_a_prefilter() {
let source = include_str!("../src/raw_transaction.rs");
let exact_sql = source.find("const SELECT_EXACT_NATIVE_VARIANT_SQL");
let exact_helper = source.find("async fn persist_or_reuse_native_transaction_variant(");
assert!(exact_sql.is_some());
assert!(exact_helper.is_some());
assert!(source.contains("content_hash = $6 AND payload = $7"));
assert!(source.contains("block_time_unix_millis IS NOT DISTINCT FROM $3"));
assert!(source.contains("origin_kind = 'native'"));
assert!(!source.contains("UNIQUE (transaction_signature, content_hash)"));
return;
}
#[test]
fn v0_3_16_pre_004_legacy_observation_without_mapping_is_not_fabricated() {
let source = include_str!("../src/raw_transaction.rs");
let start = source.find("async fn persist_transaction_variant_link(");
let end = source.find("async fn rehydrate_canonical_transaction_variant(");
let (start, end) = match (start, end) {
(std::option::Option::Some(start), std::option::Option::Some(end)) if start < end => (start, end),
_ => panic!("pre.004 observation-variant link markers are missing"),
};
let body = &source[start..end];
assert!(body.contains("RawObservationWriteOutcome::Inserted"));
assert!(body.contains("RawObservationWriteOutcome::AlreadyPresent"));
assert!(body.contains("Ok(std::option::Option::None) => return std::result::Result::Ok(())"));
return;
}
#[test]
fn v0_3_16_pre_004_keeps_comparator_and_durable_conflict_scope_deferred() {
let source = include_str!("../src/raw_transaction.rs");
assert!(!source.contains("RawTransactionVariantRelation::"));
assert!(!source.contains("INSERT INTO ksp_raw_transaction_conflicts"));
assert!(!source.contains("UPDATE ksp_raw_transaction_canonical_selectors SET canonical_variant_id"));
return;
}