diff --git a/crates/ksp-worker-raw-transaction-ingest-lib/tests/hardening.rs b/crates/ksp-worker-raw-transaction-ingest-lib/tests/hardening.rs index 80cf7ee..e295ca7 100644 --- a/crates/ksp-worker-raw-transaction-ingest-lib/tests/hardening.rs +++ b/crates/ksp-worker-raw-transaction-ingest-lib/tests/hardening.rs @@ -1,7 +1,7 @@ // file: crates/ksp-worker-raw-transaction-ingest-lib/tests/hardening.rs -// version: 37 +// version: 38 -//! External public, security, redaction and release-boundary hardening canaries through `v0.3.14-pre.011`. +//! External public, security, redaction and release-boundary hardening canaries through `v0.3.15-pre.004`. fn network(value: &'static str) -> std::option::Option { let result = ksp_store_lib::RawNetworkId::new(value); @@ -1374,3 +1374,42 @@ fn v0_3_14_pre_013_cross_layer_completeness_security_closure_is_exact_and_redact } return; } + +#[test] +fn v0_3_15_pre_004_websocket_source_constructors_enforce_transport_capabilities_before_io() { + let resources = include_str!("../src/runtime_resources.rs"); + for required in [ + "supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::Logs)", + "runtime_resources.standard_logs_capability_missing", + "supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::Block)", + "runtime_resources.standard_block_capability_missing", + "supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::HeliusTransaction)", + "runtime_resources.helius_transaction_capability_missing", + ] { + assert!(resources.contains(required), "required pre.004 WebSocket capability enforcement missing: {required}"); + } + let logs_impl = match resources.split_once("impl crate::RawTransactionIngestStandardLogsSource {") { + std::option::Option::Some((_, tail)) => tail, + std::option::Option::None => "", + }; + let block_impl = match resources.split_once("impl crate::RawTransactionIngestStandardBlockSource {") { + std::option::Option::Some((_, tail)) => tail, + std::option::Option::None => "", + }; + let helius_impl = match resources.split_once("impl crate::RawTransactionIngestHeliusTransactionSource {") { + std::option::Option::Some((_, tail)) => tail, + std::option::Option::None => "", + }; + let logs_capability = logs_impl.find("supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::Logs)"); + let logs_connect = logs_impl.find("SolanaStandardWsSession::connect"); + let block_capability = block_impl.find("supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::Block)"); + let block_connect = block_impl.find("SolanaStandardWsSession::connect"); + let helius_capability = helius_impl.find("supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::HeliusTransaction)"); + let helius_connect = helius_impl.find("HeliusLaserStreamWsSession::connect"); + assert!(matches!((logs_capability, logs_connect), (std::option::Option::Some(capability), std::option::Option::Some(connect)) if capability < connect)); + assert!(matches!((block_capability, block_connect), (std::option::Option::Some(capability), std::option::Option::Some(connect)) if capability < connect)); + assert!(matches!((helius_capability, helius_connect), (std::option::Option::Some(capability), std::option::Option::Some(connect)) if capability < connect)); + assert!(!resources.contains("provider_supports_subscription")); + assert!(!resources.contains("match ws_endpoint.provider()")); + return; +} diff --git a/crates/ksp-worker-raw-transaction-ingest-lib/tests/release_completeness.rs b/crates/ksp-worker-raw-transaction-ingest-lib/tests/release_completeness.rs index b6d2fb6..604c9f9 100644 --- a/crates/ksp-worker-raw-transaction-ingest-lib/tests/release_completeness.rs +++ b/crates/ksp-worker-raw-transaction-ingest-lib/tests/release_completeness.rs @@ -1,7 +1,7 @@ // file: crates/ksp-worker-raw-transaction-ingest-lib/tests/release_completeness.rs -// version: 32 +// version: 33 -//! Release-completeness canaries through the `v0.3.14-pre.013` cross-layer closure tranche. +//! Release-completeness canaries through the `v0.3.15-pre.004` WebSocket capability-enforcement tranche. #[test] fn pre_010_production_module_inventory_is_exact() -> std::io::Result<()> { @@ -463,3 +463,23 @@ fn v0_3_14_pre_013_cross_layer_closure_canaries_are_complete_without_behavior_or assert!(include_str!("../src/lib.rs").contains("RawTransactionIngestWorker")); return; } + +#[test] +fn v0_3_15_pre_004_websocket_capability_enforcement_canaries_are_complete_without_public_surface_growth() { + let resource_tests = include_str!("../unit_tests/runtime_resources.rs"); + let hardening = include_str!("hardening.rs"); + let root = include_str!("../src/lib.rs"); + assert!(resource_tests.contains("v0_3_15_pre_004_websocket_route_constructors_require_explicit_capability_before_io")); + assert!(hardening.contains("v0_3_15_pre_004_websocket_source_constructors_enforce_transport_capabilities_before_io")); + for required in [ + "runtime_resources.standard_logs_capability_missing", + "runtime_resources.standard_block_capability_missing", + "runtime_resources.helius_transaction_capability_missing", + ] { + assert!(resource_tests.contains(required), "required pre.004 route-constructor canary missing: {required}"); + } + assert!(!root.contains("WsSubscriptionKind")); + assert!(!root.contains("subscription_capabilities")); + assert!(!root.contains("supports_subscription")); + return; +} diff --git a/deltas/0.3.15/pre.004.md b/deltas/0.3.15/pre.004.md new file mode 100644 index 0000000..a809235 --- /dev/null +++ b/deltas/0.3.15/pre.004.md @@ -0,0 +1,63 @@ + + + +# Delta v0.3.15-pre.004 — Worker WebSocket capability enforcement + +## Objet + +Fermer le gap Worker identifié en `pre.001` puis rendu exprimable par Transport `pre.002` et Config `pre.003` : une source WebSocket live ne doit plus être constructible si l'endpoint n'annonce pas explicitement la famille de subscription requise. + +## Changements + +- bump workspace `0.3.15-pre.3` -> `0.3.15-pre.4` ; +- `RawTransactionIngestStandardLogsSource::new(...)` exige `WsSubscriptionKind::Logs` ; +- `RawTransactionIngestStandardBlockSource::new(...)` exige `WsSubscriptionKind::Block` ; +- `RawTransactionIngestHeliusTransactionSource::new(...)` exige `WsSubscriptionKind::HeliusTransaction` ; +- l'enforcement s'appuie exclusivement sur `WsEndpointSettings::supports_subscription(...)` et n'infère rien depuis le provider ; +- la validation protocole reste antérieure au contrôle capability ; +- l'état legacy `subscription_capabilities = None` échoue donc fail-closed dans ces constructeurs Worker ; +- Yellowstone et HTTP Block Polling restent inchangés, n'étant pas des sources WS ; +- les fixtures historiques Worker déclarent maintenant explicitement les capabilities Transport qu'elles simulent ; +- ajout de canaris unitaires, hardening et release-completeness, sans nouvelle surface publique ni dépendance. + +## Frontières préservées + +- aucune dépendance `ksp-config-lib` dans le Worker ; +- aucune branche sur un provider/tier pour décider d'une capability ; +- aucune I/O réseau pendant la construction des routes ; +- aucune nouvelle API publique Worker ; +- aucun changement Store, Config ou Desk ; +- aucune implémentation du scaffold applicatif avant `pre.005`. + +## Validation d'assemblage + +À l'assemblage sans toolchain Rust/Cargo disponible : + +```text +python3 scripts/audit_rust_workspace_rules.py +python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.3.15 +``` + +Résultat : + +```text +General Rust rule audit: clean +Rust export completeness audit: 0 candidate(s) +KSP workspace Rust rule audit: clean +Markdown table audit: clean (318 table(s), 189 file(s)) +``` + +Les gates Cargo restent à exécuter sur le poste opérateur. La baseline `pre.003` fournie par l'opérateur est entièrement PASS, y compris `cargo test --workspace --all-targets --all-features`. + +## Gate opérateur attendu + +```bash +cargo fmt --all +cargo fmt --all -- --check +python3 scripts/audit_rust_workspace_rules.py +python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.3.15 +cargo check --workspace +cargo clippy --workspace --all-targets --all-features -- -D warnings +cargo test -p ksp-worker-raw-transaction-ingest-lib --all-targets --all-features +cargo test --workspace --all-targets --all-features +``` diff --git a/docs/validation/032-V0_3_15_RAW_TRANSACTION_INGEST_DESK.md b/docs/validation/032-V0_3_15_RAW_TRANSACTION_INGEST_DESK.md index ed22c4b..bb647cd 100644 --- a/docs/validation/032-V0_3_15_RAW_TRANSACTION_INGEST_DESK.md +++ b/docs/validation/032-V0_3_15_RAW_TRANSACTION_INGEST_DESK.md @@ -1,5 +1,5 @@ - + # Validation v0.3.15 — Raw Transaction Ingest Desk @@ -348,11 +348,11 @@ Le forecast durable est porté par la section 20 du plan `036` sous forme hiéra ### `pre.003` — Config capability/composite -**Statut : réalisé côté assemblage ; gate Cargo opérateur requis.** Schema/mapping capabilities WS + composite/profils Raw Ingest Desk. Les profils standard committed déclarent la surface stable sans `Block`, les profils Helius déclarent explicitement `HeliusTransaction` sans `Block`/`Vote`, et les profils du composite Raw Ingest Desk couplent Transport+Store sur le même réseau. +**Statut : réalisé et gate opérateur PASS.** Schema/mapping capabilities WS + composite/profils Raw Ingest Desk. Les profils standard committed déclarent la surface stable sans `Block`, les profils Helius déclarent explicitement `HeliusTransaction` sans `Block`/`Vote`, et les profils du composite Raw Ingest Desk couplent Transport+Store sur le même réseau. Le gate opérateur passe `cargo check`, Clippy `-D warnings`, `cargo test -p ksp-config-lib --all-targets --all-features` (`130` tests unitaires PASS) et `cargo test --workspace --all-targets --all-features`. ### `pre.004` — Worker enforcement -Enforcement des capabilities WS déclarées + canaris route constructors. +**Statut : réalisé côté assemblage ; gate Cargo opérateur requis.** Les trois constructeurs de routes WS (`Standard Logs`, `Standard Block`, `Helius Transaction`) exigent la capability Transport exacte via `supports_subscription(...)` et refusent l'état undeclared/capability absente avant toute I/O. Le protocole reste validé avant la capability afin de conserver des diagnostics stables. Yellowstone et HTTP Block Polling ne sont pas concernés. Des canaris unitaires prouvent le refus undeclared/mauvaise capability et l'acceptation de la capability exacte ; les canaris hardening/release-completeness prouvent l'ordre avant `connect`, l'absence de logique provider et l'absence de croissance de surface publique. ### `pre.005` — scaffold Desk