From 8b6ef7778a02d6babc3567ff00ae854c36f1e17a Mon Sep 17 00:00:00 2001 From: SinuS Von SifriduS Date: Thu, 10 Sep 2026 21:55:02 +0200 Subject: [PATCH] v0.3.13-pre.012 --- Cargo.toml | 4 +- .../tests/cross_layer_completeness.rs | 177 +++++++++++++++++- .../tests/dependency_boundary.rs | 32 +++- .../tests/hardening.rs | 29 ++- .../tests/public_api.rs | 21 ++- .../tests/release_completeness.rs | 24 ++- deltas/0.3.13/pre.012.md | 75 ++++++++ ...3_13_MULTI_SOURCE_LIVE_CONVERGENCE_PLAN.md | 84 ++++++++- ...0-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE.md | 68 ++++++- 9 files changed, 502 insertions(+), 12 deletions(-) create mode 100644 deltas/0.3.13/pre.012.md diff --git a/Cargo.toml b/Cargo.toml index 4fcd103..90345b5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,12 +1,12 @@ # file: Cargo.toml -# version: 560 +# version: 561 [workspace] resolver = "3" members = ["crates/ksp-app-backfill-desk", "crates/ksp-app-config-desk", "crates/ksp-app-solprices-desk", "crates/ksp-app-store-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-interface-lib", "crates/ksp-job-api", "crates/ksp-job-backfill-lib", "crates/ksp-logging-lib", "crates/ksp-offchain-transport-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-program-api", "crates/ksp-raw-transaction-lib", "crates/ksp-store-api", "crates/ksp-store-lib", "crates/ksp-store-postgres-lib", "crates/ksp-wallet-lib", "crates/ksp-worker-api", "crates/ksp-worker-raw-transaction-ingest-lib"] [workspace.package] -version = "0.3.13-pre.11" +version = "0.3.13-pre.12" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project" diff --git a/crates/ksp-worker-raw-transaction-ingest-lib/tests/cross_layer_completeness.rs b/crates/ksp-worker-raw-transaction-ingest-lib/tests/cross_layer_completeness.rs index e22e5d9..90a2beb 100644 --- a/crates/ksp-worker-raw-transaction-ingest-lib/tests/cross_layer_completeness.rs +++ b/crates/ksp-worker-raw-transaction-ingest-lib/tests/cross_layer_completeness.rs @@ -1,7 +1,7 @@ // file: crates/ksp-worker-raw-transaction-ingest-lib/tests/cross_layer_completeness.rs -// version: 1 +// version: 2 -//! Cross-layer completeness and security canaries for `0.3.12-pre.010`. +//! Cross-layer completeness and security canaries through `0.3.13-pre.012`. fn dependency_names(manifest: &str) -> std::vec::Vec<&str> { let mut section = ""; @@ -190,3 +190,176 @@ fn v0_3_12_pre_010_public_roots_keep_implementation_modules_private() { } return; } + +#[test] +fn v0_3_13_pre_012_all_five_live_source_families_share_one_worker_common_raw_store_pipeline() { + let transport_root = include_str!("../../ksp-onchain-transport-lib/src/lib.rs"); + let transport_http_transactions = include_str!("../../ksp-onchain-transport-lib/src/rpc_transactions.rs"); + let transport_http_blocks = include_str!("../../ksp-onchain-transport-lib/src/rpc_blocks.rs"); + let transport_ws_protocol = include_str!("../../ksp-onchain-transport-lib/src/ws_protocol_session.rs"); + let transport_grpc_stream = include_str!("../../ksp-onchain-transport-lib/src/grpc_stream.rs"); + let worker_resources = include_str!("../src/runtime_resources.rs"); + let worker_persistence = include_str!("../src/persistence.rs"); + let common_raw_root = include_str!("../../ksp-raw-transaction-lib/src/lib.rs"); + let store_root = include_str!("../../ksp-store-lib/src/lib.rs"); + let store = include_str!("../../ksp-store-lib/src/store.rs"); + for required in [ + "HeliusTransaction(crate::RawTransactionIngestHeliusTransactionSource)", + "HttpBlockPolling(crate::RawTransactionIngestHttpBlockPollingSource)", + "StandardBlock(crate::RawTransactionIngestStandardBlockSource)", + "StandardLogs(crate::RawTransactionIngestStandardLogsSource)", + "Yellowstone(crate::RawTransactionIngestYellowstoneSource)", + "RawTransactionIngestGlobalHydrationRegistry", + "run_live_sources", + "RawTransactionIngress", + ] { + assert!(worker_resources.contains(required), "pre.012 Worker source/pipeline contract missing: {required}"); + } + for required in ["persist_raw_transaction_ingest_converged_acquisition", "RawTransactionIngestPersistenceConvergence", "record_observation"] { + assert!(worker_persistence.contains(required), "pre.012 Worker persistence contract missing: {required}"); + } + for required in ["SolanaStandardWsSession", "HeliusLaserStreamWsSession"] { + assert!(transport_ws_protocol.contains(required), "pre.012 WS Transport facade missing: {required}"); + } + assert!(transport_grpc_stream.contains("pub struct SolanaYellowstoneGrpcSubscribeSession")); + assert!(transport_http_transactions.contains("pub async fn get_transaction_observed(")); + assert!(transport_http_blocks.contains("pub async fn get_block_observed(")); + assert!(transport_http_blocks.contains("pub async fn get_blocks_with_limit(")); + for required in ["RawTransactionAcquisition", "RawSolanaMessageVersion", "RawSolanaTransactionWire"] { + assert!(common_raw_root.contains(required), "pre.012 Common RAW contract missing: {required}"); + } + for required in ["RawTransactionWrite", "RawTransactionObservationWrite", "RawPayload"] { + assert!(store_root.contains(required), "pre.012 Store facade contract missing: {required}"); + } + for required in ["persist_raw_transaction_acquisition", "record_raw_transaction_observation"] { + assert!(store.contains(required), "pre.012 Store dispatch contract missing: {required}"); + } + assert!(!transport_root.contains("ksp_raw_transaction_lib")); + return; +} + +#[test] +fn v0_3_13_pre_012_legacy_v0_v1_is_proven_from_transport_through_worker_common_raw_to_store() { + let transport_grpc = include_str!("../../ksp-onchain-transport-lib/unit_tests/grpc_subscribe.rs"); + let transport_blocks = include_str!("../../ksp-onchain-transport-lib/unit_tests/rpc_blocks.rs"); + let worker = include_str!("../unit_tests/runtime_resources.rs"); + let worker_resources = include_str!("../src/runtime_resources.rs"); + let worker_persistence = include_str!("../src/persistence.rs"); + let common_raw_wire = include_str!("../../ksp-raw-transaction-lib/unit_tests/wire.rs"); + let common_raw_canonical = include_str!("../../ksp-raw-transaction-lib/unit_tests/canonical.rs"); + let store_api = include_str!("../../ksp-store-api/tests/public_api.rs"); + let store = include_str!("../../ksp-store-lib/src/store.rs"); + assert!(transport_grpc.contains("yellowstone_transaction_update_decodes_current_storage_wire_including_v1_config_and_meta")); + assert!(transport_blocks.contains("typed_get_block_modern_full_config_preserves_rich_wire_and_simd_fields")); + for required in [ + "v0_3_13_pre_004_standard_block_qualifies_legacy_v0_v1_and_rejects_ambiguous_or_future_versions", + "v0_3_13_pre_004_legacy_v0_v1_block_materials_are_direct_common_raw_with_exact_version_and_index", + "v0_3_13_pre_006_http_block_polling_qualifies_legacy_v0_v1_and_rejects_ambiguous_or_future_versions", + "RawSolanaMessageVersion::Legacy", + "RawSolanaMessageVersion::V0", + "RawSolanaMessageVersion::V1", + ] { + assert!(worker.contains(required), "pre.012 Worker Legacy/V0/V1 proof missing: {required}"); + } + assert!(worker_resources.contains("SolanaGetTransactionConfig::new")); + assert!(worker_resources.contains("std::option::Option::Some(1),")); + for required in [ + "pre_006_legacy_v0_and_v1_wire_goldens_are_exact", + "pre_006_v1_structural_guards_reject_alt_duplicates_and_missing_config", + "RawSolanaMessageVersion::V1", + ] { + assert!(common_raw_wire.contains(required), "pre.012 Common RAW V1 proof missing: {required}"); + } + assert!(common_raw_canonical.contains("pre_002_canonical_raw_v1_golden_bytes_and_hash_are_exact")); + for required in ["block_time", "content_hash", "format_id", "format_version", "slot"] { + assert!(worker_persistence.contains(required), "pre.012 canonical Store identity field missing: {required}"); + } + assert!(store_api.contains("public_pre_003_raw_transaction_and_observation_are_constructible_from_crate_root")); + assert!(store_api.contains("RawPayload::try_new(format, 1")); + assert!(store.contains("persist_raw_transaction_acquisition")); + assert!(store.contains("record_raw_transaction_observation")); + return; +} + +#[test] +fn v0_3_13_pre_012_yellowstone_non_regression_covers_identity_v1_reconnect_gap_and_worker_hydration() { + let transport_subscribe = include_str!("../../ksp-onchain-transport-lib/unit_tests/grpc_subscribe.rs"); + let transport_stream = include_str!("../../ksp-onchain-transport-lib/unit_tests/grpc_stream.rs"); + let transport_public = include_str!("../../ksp-onchain-transport-lib/tests/public_api.rs"); + let worker = include_str!("../unit_tests/runtime_resources.rs"); + let worker_hardening = include_str!("hardening.rs"); + for required in [ + "yellowstone_subscribe_request_identity_is_order_stable_exact_and_debug_redacted", + "yellowstone_transaction_update_decodes_current_storage_wire_including_v1_config_and_meta", + "yellowstone_transaction_status_update_preserves_error_and_rejects_malformed_signature", + "yellowstone_block_update_reuses_transaction_account_entry_dtos_and_preserves_server_counts", + ] { + assert!(transport_subscribe.contains(required), "pre.012 Yellowstone Transport subscribe proof missing: {required}"); + } + for required in [ + "yellowstone_reconnect_replays_from_last_observed_slot_and_counts_duplicate_identity", + "yellowstone_replay_info_proves_and_clamps_retention_gap_without_lossless_claim", + "yellowstone_shutdown_interrupts_reconnect_backoff_and_mutation_is_rejected_during_reconnect", + ] { + assert!(transport_stream.contains(required), "pre.012 Yellowstone Transport lifecycle proof missing: {required}"); + } + assert!(transport_public.contains("public_v0_3_13_pre_002_yellowstone_subscribe_identity_is_opaque_and_available_from_crate_root")); + for required in [ + "pre_002_source_accepts_matching_confirmed_transaction_and_get_transaction_route_without_io", + "v0_3_13_pre_002_live_source_key_is_stable_and_request_sensitive", + "pre_003_transaction_signal_fixture_preserves_exact_source_neutral_identity", + "pre_005_block_projects_transaction_signals_in_exact_source_order", + "pre_005_block_meta_and_slot_project_continuity_only_without_remote_dead_error", + "pre_004_observed_get_transaction_closes_signal_to_common_raw_ingress_with_composite_provenance", + "pre_008_reconnect_replay_and_proven_gap_are_distinct_monotone_and_frontier_preserving", + "v0_3_13_pre_008_global_hydration_registry_coalesces_cross_source_key_to_one_leader", + ] { + assert!(worker.contains(required), "pre.012 Yellowstone Worker non-regression proof missing: {required}"); + } + for required in [ + "v0_3_12_pre_003_private_signal_debug_and_shape_do_not_expose_signature_filters_or_payload", + "v0_3_12_pre_008_reconnect_projection_is_source_neutral_bounded_and_contains_no_replay_material", + ] { + assert!(worker_hardening.contains(required), "pre.012 Yellowstone Worker hardening proof missing: {required}"); + } + return; +} + +#[test] +fn v0_3_13_pre_012_security_redaction_matrix_covers_all_live_sources_and_lower_layers() { + let transport_subscribe = include_str!("../../ksp-onchain-transport-lib/unit_tests/grpc_subscribe.rs"); + let transport_unary = include_str!("../../ksp-onchain-transport-lib/unit_tests/grpc_unary.rs"); + let transport_ws = include_str!("../../ksp-onchain-transport-lib/unit_tests/ws_helius_transactions.rs"); + let worker = include_str!("hardening.rs"); + let common_raw = include_str!("../../ksp-raw-transaction-lib/unit_tests/canonical.rs"); + let store_api = include_str!("../../ksp-store-api/tests/security_hardening.rs"); + let store = include_str!("../../ksp-store-lib/tests/hardening_completeness.rs"); + let postgres = include_str!("../../ksp-store-postgres-lib/tests/hardening_completeness.rs"); + for required in [ + "yellowstone_subscribe_debug_omits_filter_names_and_future_payloads", + "yellowstone_transaction_filters_encode_complete_current_wire_and_redact_selectors", + ] { + assert!(transport_subscribe.contains(required), "pre.012 Transport gRPC redaction proof missing: {required}"); + } + assert!(transport_unary.contains("yellowstone_remote_status_does_not_copy_message_details_or_metadata")); + assert!(transport_ws.contains("helius_transaction_notification_debug_omits_raw_provider_payloads")); + for required in [ + "v0_3_12_pre_003_private_signal_debug_and_shape_do_not_expose_signature_filters_or_payload", + "v0_3_13_pre_003_standard_logs_redaction_and_reference_only_contract_are_explicit", + "v0_3_13_pre_004_standard_block_redaction_version_and_null_guards_are_explicit", + "v0_3_13_pre_005_helius_transaction_redaction_full_reference_and_tier_neutrality_are_explicit", + "v0_3_13_pre_006_http_block_polling_is_bounded_run_local_stop_preemptible_and_redacted", + "v0_3_13_pre_007_multi_source_supervisor_is_fail_closed_joined_and_does_not_publish_source_identity", + "v0_3_13_pre_008_cross_source_convergence_is_bounded_conflict_checked_and_private", + "v0_3_13_pre_009_duplicate_storm_disagreement_and_starvation_guards_are_explicit", + "v0_3_13_pre_010_multi_source_health_is_conservative_counted_and_redacted", + "v0_3_13_pre_011_shutdown_races_are_bounded_joined_atomic_and_counter_safe", + ] { + assert!(worker.contains(required), "pre.012 Worker security proof missing: {required}"); + } + assert!(common_raw.contains("pre_002_material_and_wire_debug_do_not_render_transaction_or_meta_material")); + assert!(store_api.contains("pre_007_raw_debug_surfaces_do_not_render_payload_hash_signature_or_account_bytes")); + assert!(store.contains("pre_009_secret_canary_never_crosses_settings_or_pre_io_error_debug")); + assert!(postgres.contains("pre_009_backend_error_bridge_cannot_retain_external_error_or_secret_text")); + return; +} diff --git a/crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs b/crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs index 43524da..814b7c0 100644 --- a/crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs +++ b/crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs @@ -1,5 +1,5 @@ // file: crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs -// version: 28 +// version: 29 //! Dependency firewall canaries for the RAW transaction ingest Worker foundation. @@ -702,3 +702,33 @@ fn v0_3_13_pre_011_shutdown_race_hardening_stays_inside_worker_and_existing_faca } return; } + +#[test] +fn v0_3_13_pre_012_cross_layer_closure_does_not_expand_worker_dependency_graph() { + let manifest = include_str!("../Cargo.toml"); + let dependencies = dependency_section(manifest); + let names = manifest_dependency_names(dependencies); + assert_eq!( + names, + vec![ + "ksp-core-lib", + "ksp-logging-lib", + "ksp-onchain-transport-lib", + "ksp-raw-transaction-lib", + "ksp-store-lib", + "ksp-worker-api", + "sha2", + "tokio", + ], + ); + let cross_layer = include_str!("cross_layer_completeness.rs"); + for required in [ + "v0_3_13_pre_012_all_five_live_source_families_share_one_worker_common_raw_store_pipeline", + "v0_3_13_pre_012_legacy_v0_v1_is_proven_from_transport_through_worker_common_raw_to_store", + "v0_3_13_pre_012_yellowstone_non_regression_covers_identity_v1_reconnect_gap_and_worker_hydration", + "v0_3_13_pre_012_security_redaction_matrix_covers_all_live_sources_and_lower_layers", + ] { + assert!(cross_layer.contains(required), "pre.012 cross-layer closure proof missing: {required}"); + } + return; +} 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 0bb4ced..4d91639 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: 23 +// version: 24 -//! External public, security, redaction and release-boundary hardening canaries through `pre.011`. +//! External public, security, redaction and release-boundary hardening canaries through `pre.012`. fn network(value: &'static str) -> std::option::Option { let result = ksp_store_lib::RawNetworkId::new(value); @@ -932,3 +932,28 @@ fn v0_3_13_pre_011_shutdown_races_are_bounded_joined_atomic_and_counter_safe() { assert!(!resources.contains("unbounded_channel")); return; } + +#[test] +fn v0_3_13_pre_012_cross_layer_security_closure_is_complete_and_source_neutral() { + let cross_layer = include_str!("cross_layer_completeness.rs"); + for required in [ + "v0_3_13_pre_012_legacy_v0_v1_is_proven_from_transport_through_worker_common_raw_to_store", + "v0_3_13_pre_012_yellowstone_non_regression_covers_identity_v1_reconnect_gap_and_worker_hydration", + "v0_3_13_pre_012_security_redaction_matrix_covers_all_live_sources_and_lower_layers", + ] { + assert!(cross_layer.contains(required), "pre.012 security closure proof missing: {required}"); + } + let root = include_str!("../src/lib.rs"); + for forbidden in [ + "SourceSnapshotByKey", + "SourceHealthByKey", + "provider_health", + "endpoint_health", + "RawTransactionIngestGlobalHydrationRegistry", + "RawTransactionIngestCanonicalState", + "source_key", + ] { + assert!(!root.contains(forbidden), "pre.012 public root leaked private/source-specific material: {forbidden}"); + } + return; +} diff --git a/crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs b/crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs index c09a706..3004037 100644 --- a/crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs +++ b/crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs @@ -1,5 +1,5 @@ // file: crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs -// version: 21 +// version: 22 //! External public-surface proofs for the RAW transaction ingest Worker foundation. @@ -409,3 +409,22 @@ fn v0_3_13_pre_011_race_hardening_adds_no_public_runtime_or_source_identity_surf ); return; } + +#[test] +fn v0_3_13_pre_012_completeness_closure_adds_no_public_implementation_surface() { + let root = include_str!("../src/lib.rs"); + assert!(!root.contains("pub mod ")); + for forbidden in [ + "pub use self::runtime_resources::RawTransactionIngestLiveSource", + "pub use self::runtime_resources::RawTransactionIngestSourceInventory", + "pub use self::runtime_resources::RawTransactionIngestGlobalHydrationRegistry", + "pub use self::persistence::RawTransactionIngestCanonicalState", + "pub use self::persistence::RawTransactionIngestPersistenceConvergence", + ] { + assert!(!root.contains(forbidden), "pre.012 private implementation leaked through public root: {forbidden}"); + } + let cross_layer = include_str!("cross_layer_completeness.rs"); + assert!(cross_layer.contains("v0_3_13_pre_012_all_five_live_source_families_share_one_worker_common_raw_store_pipeline")); + assert!(cross_layer.contains("v0_3_13_pre_012_legacy_v0_v1_is_proven_from_transport_through_worker_common_raw_to_store")); + 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 a15de6d..fdd0ea3 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: 19 +// version: 20 -//! Release-completeness canaries through the `pre.011` races/shutdown hardening tranche. +//! Release-completeness canaries through the `pre.012` cross-layer completeness/security tranche. #[test] fn pre_010_production_module_inventory_is_exact() -> std::io::Result<()> { @@ -215,3 +215,23 @@ fn v0_3_12_pre_010_cross_layer_completeness_suite_is_present_and_exact() -> std: } return std::result::Result::Ok(()); } + +#[test] +fn v0_3_13_pre_012_cross_layer_completeness_security_inventory_is_exact() { + let cross_layer = include_str!("cross_layer_completeness.rs"); + for required in [ + "v0_3_13_pre_012_all_five_live_source_families_share_one_worker_common_raw_store_pipeline", + "v0_3_13_pre_012_legacy_v0_v1_is_proven_from_transport_through_worker_common_raw_to_store", + "v0_3_13_pre_012_yellowstone_non_regression_covers_identity_v1_reconnect_gap_and_worker_hydration", + "v0_3_13_pre_012_security_redaction_matrix_covers_all_live_sources_and_lower_layers", + ] { + assert!(cross_layer.contains(required), "required pre.012 cross-layer canary missing: {required}"); + } + let dependency_boundary = include_str!("dependency_boundary.rs"); + let hardening = include_str!("hardening.rs"); + let public_api = include_str!("public_api.rs"); + assert!(dependency_boundary.contains("v0_3_13_pre_012_cross_layer_closure_does_not_expand_worker_dependency_graph")); + assert!(hardening.contains("v0_3_13_pre_012_cross_layer_security_closure_is_complete_and_source_neutral")); + assert!(public_api.contains("v0_3_13_pre_012_completeness_closure_adds_no_public_implementation_surface")); + return; +} diff --git a/deltas/0.3.13/pre.012.md b/deltas/0.3.13/pre.012.md new file mode 100644 index 0000000..38c2e31 --- /dev/null +++ b/deltas/0.3.13/pre.012.md @@ -0,0 +1,75 @@ + + + +# Delta 0.3.13-pre.012 — completeness/security cross-layer + +## Objet + +Fermer la matrice de preuves cross-layer avant le gate technique/live `pre.013`, sans modifier le comportement runtime, l'API publique, Transport, Common RAW, Store, les dépendances ou les features. + +## Gate opérateur d'entrée + +Le gate `0.3.13-pre.011` communiqué le 10 septembre 2026 est vert : + +```text +fmt : PASS +audits Rust : clean / export completeness 0 +Markdown : clean, 340 tables / 849 files +cargo check --workspace : PASS +clippy strict : PASS +Worker unit : 106/106 PASS +cross_layer_completeness : 4/4 PASS +dependency_boundary : 18/18 PASS +hardening : 25/25 PASS +public_api : 19/19 PASS +release_completeness : 4/4 PASS +Worker doc-tests : 0/0 PASS +``` + +## Modifications + +La suite `cross_layer_completeness` ajoute quatre preuves obligatoires : + +```text +cinq familles live -> pipeline Worker/Common RAW/Store unique +Legacy/V0/V1 -> Transport/Worker/Common RAW/Store +non-régression Yellowstone -> identity/V1/reconnect/gap/hydration +security/redaction -> Transport/Worker/Common RAW/Store API/Store/PostgreSQL +``` + +Les suites `dependency_boundary`, `hardening`, `public_api` et `release_completeness` verrouillent explicitement la présence de cette matrice. + +## Frontières + +```text +aucun code production modifié +aucune API publique ajoutée +aucune dépendance/feature modifiée +aucun changement Transport/Common RAW/Store +aucun delta historique modifié +``` + +## Validation locale d'assemblage + +Le toolchain Cargo/Rustfmt n'est pas disponible dans l'environnement d'assemblage. Aucune commande Cargo post-modification n'est déclarée PASS localement. + +Les audits statiques et les contrôles archive sont consignés uniquement après leur exécution effective. + +## Gate opérateur vers pre.013 + +`pre.013` est le gate technique/live de fermeture ; exécuter : + +```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 +cargo check --workspace +cargo clippy --workspace --all-targets --all-features -- -D warnings +cargo test --workspace --all-targets --all-features +cargo tree -p ksp-worker-raw-transaction-ingest-lib --edges normal +cargo tree -p ksp-worker-raw-transaction-ingest-lib -e features +cargo tree --duplicates +``` + +Les smokes live accessibles sont qualifiés dans `pre.013`; un smoke inaccessible reste `NON EXÉCUTÉ`. diff --git a/docs/plans/034-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE_PLAN.md b/docs/plans/034-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE_PLAN.md index 3afb551..39d843c 100644 --- a/docs/plans/034-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE_PLAN.md +++ b/docs/plans/034-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE_PLAN.md @@ -1,5 +1,5 @@ - + # Plan v0.3.13 — WS standard / Helius / HTTP live + convergence multi-source RawTransaction @@ -1556,3 +1556,85 @@ cargo test -p ksp-worker-raw-transaction-ingest-lib ``` Aucun `cargo tree` n'est requis : `pre.011` ne modifie ni dépendance ni feature. Le Transport n'est pas modifié par cette tranche de hardening shutdown/races. + +## 86. Gate opérateur pre.011 reçu + +Le 10 septembre 2026, le gate intermédiaire communiqué pour `0.3.13-pre.011` est entièrement vert pour toutes les commandes exécutées : + +```text +fmt : PASS +audits Rust : clean / export completeness 0 +Markdown : clean, 340 tables / 849 files +cargo check --workspace : PASS +clippy strict : PASS +Worker unit : 106/106 PASS +cross_layer_completeness : 4/4 PASS +dependency_boundary : 18/18 PASS +hardening : 25/25 PASS +public_api : 19/19 PASS +release_completeness : 4/4 PASS +Worker doc-tests : 0/0 PASS +``` + +Le Transport n'était pas modifié par `pre.011` et n'a pas été rejoué. Aucun `cargo tree` n'était requis. + +## 87. Fermeture completeness/security pre.012 + +`pre.012` n'ajoute aucun comportement runtime. La tranche matérialise une matrice de fermeture cross-layer obligatoire qui relie explicitement : + +```text +Transport + -> cinq familles de sources live +Worker + -> admission/convergence/persistence communes +Common RAW + -> Legacy/V0/V1 +Store + -> RawTransaction + observations +``` + +Les quatre preuves cross-layer nouvelles couvrent : + +```text +les cinq familles Yellowstone / StandardLogs / StandardBlock / HeliusTransaction / HttpBlockPolling +Legacy/V0/V1 de Transport jusqu'au Store opaque via Worker/Common RAW +non-régression Yellowstone : request identity, V1, reconnect/replay/gap, hydration Worker +redaction/security de Transport, Worker, Common RAW, Store API, Store façade et backend PostgreSQL +``` + +Les suites `dependency_boundary`, `hardening`, `public_api` et `release_completeness` référencent explicitement ces preuves afin qu'elles ne puissent pas disparaître silencieusement. + +## 88. Frontières pre.012 + +La fermeture ne modifie pas : + +```text +code production Worker +Transport +Common RAW +Store API / Store backend +dépendances ou features +API publique +retry/reconnect/fairness/convergence/shutdown +``` + +Aucun delta historique n'est modifié. Seul `pre.012.md` est ajouté. + +## 89. Gate technique requis pour pre.013 + +`pre.013` étant la tranche explicitement réservée au gate technique/live, le gate suivant est volontairement exhaustif : + +```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 +cargo check --workspace +cargo clippy --workspace --all-targets --all-features -- -D warnings +cargo test --workspace --all-targets --all-features +cargo tree -p ksp-worker-raw-transaction-ingest-lib --edges normal +cargo tree -p ksp-worker-raw-transaction-ingest-lib -e features +cargo tree --duplicates +``` + +Les smokes live réellement accessibles seront exécutés/qualifiés dans `pre.013`. Un smoke inaccessible reste `NON EXÉCUTÉ`, jamais PASS. Aucun nouveau scope fonctionnel n'est autorisé dans `pre.013`. diff --git a/docs/validation/030-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE.md b/docs/validation/030-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE.md index cb470f0..40015a4 100644 --- a/docs/validation/030-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE.md +++ b/docs/validation/030-V0_3_13_MULTI_SOURCE_LIVE_CONVERGENCE.md @@ -1,5 +1,5 @@ - + # Validation v0.3.13 — WS standard / Helius / HTTP live + convergence multi-source @@ -1580,3 +1580,69 @@ cargo test -p ksp-worker-raw-transaction-ingest-lib ``` Aucun `cargo tree` n'est requis et le Transport n'a pas besoin d'être rejoué pour cette tranche qui ne modifie ni le graphe ni `ksp-onchain-transport-lib`. + +## 88. Gate complet pre.011 reçu + +Preuve opérateur du 10 septembre 2026 : + +```text +fmt : PASS +audits Rust : clean / export completeness 0 +Markdown : clean, 340 tables / 849 files +cargo check --workspace : PASS +clippy strict : PASS +Worker : 106 unit + 4 cross-layer + 18 dependency-boundary + 25 hardening + 19 public-api + 4 release-completeness, 0 échec +Worker doc-tests : 0 +``` + +Le Transport et les graphes n'étaient pas requis pour ce gate intermédiaire et ne sont pas revendiqués. + +## 89. Matrice cross-layer pre.012 + +La suite `cross_layer_completeness` ajoute quatre canaris de fermeture : + +```text +all_five_live_source_families_share_one_worker_common_raw_store_pipeline +legacy_v0_v1_is_proven_from_transport_through_worker_common_raw_to_store +yellowstone_non_regression_covers_identity_v1_reconnect_gap_and_worker_hydration +security_redaction_matrix_covers_all_live_sources_and_lower_layers +``` + +La matrice vérifie explicitement les façades Transport HTTP/WS/gRPC, les cinq discriminants de sources Worker, la convergence/hydration/persistence communes, les types Common RAW, puis les bridges Store `persist_raw_transaction_acquisition` et `record_raw_transaction_observation`. + +## 90. Legacy/V0/V1 et Yellowstone + +La fermeture Legacy/V0/V1 vérifie simultanément : + +```text +Yellowstone Transport conserve le matériau V1 +getBlock/getTransaction restent version-aware jusqu'à maxSupportedTransactionVersion = 1 +Standard Block et HTTP Polling qualifient Legacy/V0/V1 +Common RAW conserve les goldens Legacy/V0/V1 et le hash canonique V1 +Worker transmet slot/block_time/format_id/format_version/content_hash vers la convergence Store +Store conserve le payload RAW de manière opaque avec entity + observations +``` + +La non-régression Yellowstone vérifie séparément request identity opaque, Transaction/TransactionStatus/Block, reconnect/replay, retention gap, hydration observée et coalescence globale Worker. + +## 91. Security et absence d'élargissement + +Les canaris de fermeture prouvent : + +```text +graphe Worker normal inchangé +aucun module d'implémentation public +aucune source_key/registry/canonical state publique +redaction Yellowstone/Helius/Standard sources +redaction Common RAW +redaction Store API / Store / PostgreSQL backend +aucune dépendance réseau/backend directe ajoutée au Worker +``` + +`pre.012` est donc test/documentation-only hors bump mécanique de prerelease. + +## 92. Gate technique/live avant pre.013 + +Le toolchain Cargo/Rustfmt n'est pas disponible dans l'environnement d'assemblage ; aucun résultat Cargo post-modification n'est revendiqué localement. + +Le gate de `pre.013` est volontairement le gate de fermeture technique : workspace complet, Clippy strict, tests all-targets/all-features, graphes et duplicates. Les smokes live accessibles y sont exécutés ; les autres sont qualifiés `NON EXÉCUTÉ`.