v0.3.1-pre.003

crates/ksp-store-api/tests/dependency_boundary.rs

@@ -1,10 +1,10 @@
 // file: crates/ksp-store-api/tests/dependency_boundary.rs
-// version: 1
+// version: 2
 
-//! Dependency canaries for the Store API scaffold.
+//! Dependency canaries for the Store API RAW foundation.
 
 #[test]
-fn pre_002_manifest_has_exact_core_only_runtime_dependency() {
+fn pre_003_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,26 +49,34 @@ fn pre_002_manifest_has_exact_core_only_runtime_dependency() {
 }
 
 #[test]
-fn pre_002_source_boundary_separates_models_capabilities_and_backend_runtime() {
+fn pre_003_source_boundary_keeps_raw_models_passive_and_backend_free() {
     let crate_root = include_str!("../src/lib.rs");
+    let model_home = include_str!("../src/model.rs");
+    let raw_primitives = include_str!("../src/model/raw_primitives.rs");
+    let raw_transaction = include_str!("../src/model/raw_transaction.rs");
     assert!(crate_root.contains("mod capability;"));
+    assert!(crate_root.contains("mod error;"));
     assert!(crate_root.contains("mod model;"));
-    assert!(!crate_root.contains("pub mod "));
-    for forbidden in [
-        "ksp_store_lib",
-        "ksp_store_postgres_lib",
-        "ksp_onchain_transport_lib",
-        "ksp_program_api",
-        "serde::",
-        "sqlx::",
-        "tokio::",
-        "tokio_postgres::",
-        "std::env::",
-        "std::fs::",
-        "std::net::",
-    ] {
-        assert!(!crate_root.contains(forbidden), "forbidden Store API crate-root dependency/surface detected: {forbidden}");
+    assert!(model_home.contains("raw_primitives"));
+    assert!(model_home.contains("raw_transaction"));
+    for source in [crate_root, model_home, raw_primitives, raw_transaction] {
+        for forbidden in [
+            "ksp_store_lib",
+            "ksp_store_postgres_lib",
+            "ksp_onchain_transport_lib",
+            "ksp_program_api",
+            "serde::",
+            "sqlx::",
+            "tokio::",
+            "tokio_postgres::",
+            "std::env::",
+            "std::fs::",
+            "std::net::",
+        ] {
+            assert!(!source.contains(forbidden), "forbidden Store API dependency/runtime path detected: {forbidden}");
+        }
     }
+    assert!(!raw_transaction.contains("RawLog"));
     return;
 }
 

crates/ksp-store-api/tests/public_api.rs

@@ -1,14 +1,21 @@
 // file: crates/ksp-store-api/tests/public_api.rs
-// version: 1
+// version: 2
 
-//! Integration canaries for the public `ksp-store-api` scaffold.
+//! Integration canaries for the public `ksp-store-api` surface.
 
 fn consume_result(value: ksp_store_api::Result<ksp_store_api::Pubkey>) -> ksp_store_api::Result<ksp_store_api::Pubkey> {
     return value;
 }
 
+fn code(value: &str) -> std::option::Option<ksp_store_api::RawProvenanceCode> {
+    return match ksp_store_api::RawProvenanceCode::new(value.to_owned()) {
+        std::result::Result::Ok(value) => std::option::Option::Some(value),
+        std::result::Result::Err(_) => std::option::Option::None,
+    };
+}
+
 #[test]
-fn public_pre_002_core_facade_is_available_from_crate_root() {
+fn public_pre_002_core_facade_remains_available_from_crate_root() {
     let pubkey = ksp_store_api::Pubkey::new_from_array([0x31_u8; 32]);
     let forwarded = consume_result(std::result::Result::Ok(pubkey));
     assert!(forwarded.is_ok());
@@ -22,11 +29,54 @@ fn public_pre_002_core_facade_is_available_from_crate_root() {
 }
 
 #[test]
-fn public_pre_002_scaffold_exposes_no_private_module_paths_or_backend_types() {
+fn public_pre_003_raw_transaction_and_observation_are_constructible_from_crate_root() {
+    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let reference = ksp_store_api::RawTransactionReference::new(network, ksp_store_api::RawTransactionSignature::new([1_u8; 64]));
+    let format = match ksp_store_api::RawFormatId::new("ksp.solana.raw_transaction".to_owned()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let payload = match ksp_store_api::RawPayload::try_new(format, 1, vec![1_u8, 2_u8, 3_u8].into_boxed_slice(), ksp_store_api::RawContentHash::new([2_u8; 32]))
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let transaction = ksp_store_api::RawTransaction::new(reference.clone(), 123, std::option::Option::None, payload);
+    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1_000) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let provider = match code("provider") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let protocol = match code("solana_http") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let method = match code("getTransaction") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Backfill, received_at);
+    let observation = ksp_store_api::RawTransactionObservation::new(ksp_store_api::RawObservationKey::new([3_u8; 32]), reference, provenance);
+    assert_eq!(transaction.slot(), 123);
+    assert_eq!(transaction.payload().bytes(), &[1_u8, 2_u8, 3_u8]);
+    assert_eq!(observation.transaction().network().as_str(), "mainnet-beta");
+    assert_eq!(observation.provenance().acquisition_method().as_str(), "getTransaction");
+    assert_eq!(ksp_store_api::ERROR_CODE_RAW_PAYLOAD_INVALID.domain(), "store_api");
+    return;
+}
+
+#[test]
+fn public_pre_003_surface_keeps_backend_and_structural_types_out() {
     let source = include_str!("../src/lib.rs");
     assert!(!source.contains("pub mod "));
-    for forbidden in ["Postgres", "Sql", "Migration", "ProgramInstruction", "RawTransaction"] {
-        assert!(!source.contains(forbidden), "forbidden pre.002 Store API public concept detected: {forbidden}");
+    for forbidden in ["Postgres", "Sql", "Migration", "StructuralTransaction", "RawLog", "ProgramInstruction"] {
+        assert!(!source.contains(forbidden), "forbidden pre.003 Store API public concept detected: {forbidden}");
     }
     return;
 }