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

v0.3.1-pre.006

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-08-29 09:10:07 +02:00
parent c83e3261d0
commit b76baf6835
19 changed files with 1175 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
crates/ksp-store-api/tests/dependency_boundary.rs
View File

@@ -1,10 +1,10 @@
// file: crates/ksp-store-api/tests/dependency_boundary.rs
// version: 4
// version: 5
//! Dependency canaries for the Store API RAW foundation.
#[test]
fn pre_005_manifest_keeps_exact_core_only_runtime_dependency() {
fn pre_006_manifest_keeps_exact_core_only_runtime_dependency() {
let manifest = include_str!("../Cargo.toml");
let dependencies_tail = manifest.split("[dependencies]").nth(1);
assert!(dependencies_tail.is_some(), "Store API dependencies section must exist");
@@ -49,24 +49,45 @@ fn pre_005_manifest_keeps_exact_core_only_runtime_dependency() {
}
#[test]
fn pre_005_source_boundary_keeps_models_and_capabilities_backend_free() {
fn pre_006_source_boundary_keeps_models_and_capabilities_backend_free() {
let crate_root = include_str!("../src/lib.rs");
let model_home = include_str!("../src/model.rs");
let raw_account = include_str!("../src/model/raw_account.rs");
let raw_outcome = include_str!("../src/model/raw_outcome.rs");
let raw_pagination = include_str!("../src/model/raw_pagination.rs");
let raw_primitives = include_str!("../src/model/raw_primitives.rs");
let raw_retention = include_str!("../src/model/raw_retention.rs");
let raw_transaction = include_str!("../src/model/raw_transaction.rs");
let capability_home = include_str!("../src/capability.rs");
let raw_account_capability = include_str!("../src/capability/raw_account.rs");
let raw_retention_capability = include_str!("../src/capability/raw_retention.rs");
let raw_transaction_capability = include_str!("../src/capability/raw_transaction.rs");
assert!(crate_root.contains("mod capability;"));
assert!(crate_root.contains("mod error;"));
assert!(crate_root.contains("mod model;"));
assert!(model_home.contains("raw_account"));
assert!(model_home.contains("raw_outcome"));
assert!(model_home.contains("raw_pagination"));
assert!(model_home.contains("raw_primitives"));
assert!(model_home.contains("raw_retention"));
assert!(model_home.contains("raw_transaction"));
assert!(capability_home.contains("raw_account"));
assert!(capability_home.contains("raw_retention"));
assert!(capability_home.contains("raw_transaction"));
for source in [crate_root, model_home, raw_account, raw_primitives, raw_transaction, capability_home, raw_account_capability, raw_transaction_capability] {
for source in [
crate_root,
model_home,
raw_account,
raw_outcome,
raw_pagination,
raw_primitives,
raw_retention,
raw_transaction,
capability_home,
raw_account_capability,
raw_retention_capability,
raw_transaction_capability,
] {
for forbidden in [
"ksp_store_lib",
"ksp_store_postgres_lib",
@@ -85,12 +106,14 @@ fn pre_005_source_boundary_keeps_models_and_capabilities_backend_free() {
}
assert!(!raw_transaction.contains("RawLog"));
for forbidden in ["TransactionStatusObservation", "RawLogNotification", "RawSlotEvent", "RawVoteEvent", "RawBlock", "YellowstoneEntry"] {
assert!(!crate_root.contains(forbidden), "deferred pre.005 model leaked into Store API surface: {forbidden}");
assert!(!crate_root.contains(forbidden), "deferred pre.006 model leaked into Store API surface: {forbidden}");
}
assert!(raw_transaction_capability.contains("trait RawTransactionRead"));
assert!(raw_transaction_capability.contains("trait RawTransactionWrite"));
assert!(raw_transaction_capability.contains("trait RawTransactionObservationRead"));
assert!(raw_transaction_capability.contains("trait RawTransactionObservationWrite"));
assert!(raw_retention_capability.contains("trait RawTransactionRetentionRead"));
assert!(raw_retention_capability.contains("trait RawTransactionRetentionWrite"));
assert!(raw_account_capability.contains("trait RawAccountStateRead"));
assert!(raw_account_capability.contains("trait RawAccountStateWrite"));
assert!(raw_account_capability.contains("trait RawAccountObservationRead"));
@@ -98,8 +121,11 @@ fn pre_005_source_boundary_keeps_models_and_capabilities_backend_free() {
for forbidden in ["trait StoreBackend", "trait Store", "PostgresStore", "MySqlStore", "Arc<dyn"] {
assert!(!capability_home.contains(forbidden));
assert!(!raw_account_capability.contains(forbidden));
assert!(!raw_retention_capability.contains(forbidden));
assert!(!raw_transaction_capability.contains(forbidden));
}
assert!(raw_pagination.contains("u64::MAX") == false);
assert!(!raw_pagination.contains("MAX_RAW_PAGE_ITEMS"));
return;
}

86
crates/ksp-store-api/tests/external_backend.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-store-api/tests/external_backend.rs
// version: 1
// version: 2
//! External-implementation canary for object-safe Store API capabilities.
@@ -15,6 +15,16 @@ impl ksp_store_api::RawTransactionRead for ExternalMemoryBackend {
return std::result::Result::Ok(std::option::Option::None);
});
}
fn list_raw_transactions<'a>(
&'a self,
query: &'a ksp_store_api::RawTransactionQuery,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawTransactionReference>>> {
let _ = query;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(ksp_store_api::RawPage::new(std::vec::Vec::new(), std::option::Option::None));
});
}
}
impl ksp_store_api::RawTransactionWrite for ExternalMemoryBackend {
@@ -22,11 +32,16 @@ impl ksp_store_api::RawTransactionWrite for ExternalMemoryBackend {
&'a self,
transaction: ksp_store_api::RawTransaction,
observation: ksp_store_api::RawTransactionObservation,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
mode: ksp_store_api::RawTransactionAcquisitionMode,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
let _ = transaction;
let _ = observation;
let _ = mode;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(());
return std::result::Result::Ok(ksp_store_api::RawAcquisitionWriteOutcome::new(
ksp_store_api::RawEntityWriteOutcome::Inserted,
ksp_store_api::RawObservationWriteOutcome::Inserted,
));
});
}
}
@@ -47,10 +62,10 @@ impl ksp_store_api::RawTransactionObservationWrite for ExternalMemoryBackend {
fn record_raw_transaction_observation<'a>(
&'a self,
observation: ksp_store_api::RawTransactionObservation,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawObservationWriteOutcome>> {
let _ = observation;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(());
return std::result::Result::Ok(ksp_store_api::RawObservationWriteOutcome::Inserted);
});
}
}
@@ -65,6 +80,16 @@ impl ksp_store_api::RawAccountStateRead for ExternalMemoryBackend {
return std::result::Result::Ok(std::option::Option::None);
});
}
fn list_raw_account_states<'a>(
&'a self,
query: &'a ksp_store_api::RawAccountStateQuery,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawAccountStateReference>>> {
let _ = query;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(ksp_store_api::RawPage::new(std::vec::Vec::new(), std::option::Option::None));
});
}
}
impl ksp_store_api::RawAccountStateWrite for ExternalMemoryBackend {
@@ -72,11 +97,14 @@ impl ksp_store_api::RawAccountStateWrite for ExternalMemoryBackend {
&'a self,
state: ksp_store_api::RawAccountState,
observation: ksp_store_api::RawAccountObservation,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
let _ = state;
let _ = observation;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(());
return std::result::Result::Ok(ksp_store_api::RawAcquisitionWriteOutcome::new(
ksp_store_api::RawEntityWriteOutcome::Inserted,
ksp_store_api::RawObservationWriteOutcome::Inserted,
));
});
}
}
@@ -97,16 +125,50 @@ impl ksp_store_api::RawAccountObservationWrite for ExternalMemoryBackend {
fn record_raw_account_observation<'a>(
&'a self,
observation: ksp_store_api::RawAccountObservation,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawObservationWriteOutcome>> {
let _ = observation;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(());
return std::result::Result::Ok(ksp_store_api::RawObservationWriteOutcome::Inserted);
});
}
}
impl ksp_store_api::RawTransactionRetentionRead for ExternalMemoryBackend {
fn get_raw_transaction_retention_state<'a>(
&'a self,
reference: &'a ksp_store_api::RawTransactionReference,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawRetentionState>>> {
let _ = reference;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(std::option::Option::None);
});
}
fn get_raw_transaction_tombstone<'a>(
&'a self,
reference: &'a ksp_store_api::RawTransactionReference,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransactionTombstone>>> {
let _ = reference;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(std::option::Option::None);
});
}
}
impl ksp_store_api::RawTransactionRetentionWrite for ExternalMemoryBackend {
fn transition_raw_transaction_retention<'a>(
&'a self,
transition: ksp_store_api::RawTransactionRetentionTransition,
) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawRetentionWriteOutcome>> {
let _ = transition;
return std::boxed::Box::pin(async {
return std::result::Result::Ok(ksp_store_api::RawRetentionWriteOutcome::Applied);
});
}
}
#[test]
fn pre_005_external_backend_implements_each_capability_without_store_runtime_crate() {
fn pre_006_external_backend_implements_each_capability_without_store_runtime_crate() {
let backend = ExternalMemoryBackend;
let transaction_read: &dyn ksp_store_api::RawTransactionRead = &backend;
let transaction_write: &dyn ksp_store_api::RawTransactionWrite = &backend;
@@ -116,6 +178,8 @@ fn pre_005_external_backend_implements_each_capability_without_store_runtime_cra
let account_write: &dyn ksp_store_api::RawAccountStateWrite = &backend;
let account_observation_read: &dyn ksp_store_api::RawAccountObservationRead = &backend;
let account_observation_write: &dyn ksp_store_api::RawAccountObservationWrite = &backend;
let retention_read: &dyn ksp_store_api::RawTransactionRetentionRead = &backend;
let retention_write: &dyn ksp_store_api::RawTransactionRetentionWrite = &backend;
let _ = transaction_read;
let _ = transaction_write;
let _ = transaction_observation_read;
@@ -124,5 +188,7 @@ fn pre_005_external_backend_implements_each_capability_without_store_runtime_cra
let _ = account_write;
let _ = account_observation_read;
let _ = account_observation_write;
let _ = retention_read;
let _ = retention_write;
return;
}

35
crates/ksp-store-api/tests/public_api.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-store-api/tests/public_api.rs
// version: 4
// version: 5
//! Integration canaries for the public `ksp-store-api` surface.
@@ -146,3 +146,36 @@ fn public_pre_005_capabilities_are_available_from_crate_root_and_dyn_compatible(
assert!(account_observation_write.is_none());
return;
}
#[test]
fn public_pre_006_query_outcome_and_retention_contracts_are_available_from_crate_root() {
let limit = match ksp_store_api::RawPageLimit::new(5_000_000) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(_) => return,
};
assert_eq!(limit.get(), 5_000_000);
assert!(ksp_store_api::RawPageLimit::new(u64::MAX).is_ok());
let slots = match ksp_store_api::RawSlotRange::new(std::option::Option::Some(1), std::option::Option::Some(2)) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(_) => return,
};
let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(_) => return,
};
let query =
ksp_store_api::RawTransactionQuery::new(network, slots, ksp_store_api::RawSortDirection::Ascending, ksp_store_api::RawPageRequest::first(limit));
assert_eq!(query.page().limit().get(), 5_000_000);
let outcome =
ksp_store_api::RawAcquisitionWriteOutcome::new(ksp_store_api::RawEntityWriteOutcome::Inserted, ksp_store_api::RawObservationWriteOutcome::Inserted);
assert_eq!(outcome.entity(), ksp_store_api::RawEntityWriteOutcome::Inserted);
assert_eq!(outcome.observation(), ksp_store_api::RawObservationWriteOutcome::Inserted);
let retention_read: std::option::Option<&dyn ksp_store_api::RawTransactionRetentionRead> = std::option::Option::None;
let retention_write: std::option::Option<&dyn ksp_store_api::RawTransactionRetentionWrite> = std::option::Option::None;
assert!(retention_read.is_none());
assert!(retention_write.is_none());
assert_eq!(ksp_store_api::ERROR_CODE_RAW_CONFLICT.domain(), "store_api");
assert_eq!(ksp_store_api::ERROR_CODE_RAW_QUERY_INVALID.domain(), "store_api");
assert_eq!(ksp_store_api::ERROR_CODE_RAW_RETENTION_INVALID.domain(), "store_api");
return;
}