From cbb4e7b0de0ae5f75fb801d4331fd3b77c6c5f5b Mon Sep 17 00:00:00 2001 From: SinuS Von SifriduS Date: Sun, 23 Aug 2026 14:27:25 +0200 Subject: [PATCH] v0.2.8-pre.004-fix.002 --- Cargo.toml | 2 +- crates/ksp-config-lib/unit_tests/transport.rs | 16 +- deltas/0.2.8/pre.004-fix.002.md | 139 ++++++++++++++++++ ...0_2_8_HELIUS_LASERSTREAM_WEBSOCKET_PLAN.md | 43 ++++-- ...011-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET.md | 40 ++++- 5 files changed, 216 insertions(+), 24 deletions(-) create mode 100644 deltas/0.2.8/pre.004-fix.002.md diff --git a/Cargo.toml b/Cargo.toml index 341ab4b..65ef57e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ resolver = "3" members = ["crates/ksp-app-config-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-logging-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-wallet-lib"] [workspace.package] -version = "0.2.8-pre.4.fix.1" +version = "0.2.8-pre.4.fix.2" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project" diff --git a/crates/ksp-config-lib/unit_tests/transport.rs b/crates/ksp-config-lib/unit_tests/transport.rs index ea73437..98d9086 100644 --- a/crates/ksp-config-lib/unit_tests/transport.rs +++ b/crates/ksp-config-lib/unit_tests/transport.rs @@ -1,5 +1,5 @@ // file: crates/ksp-config-lib/unit_tests/transport.rs -// version: 5 +// version: 6 #[test] fn fixture_transport_profile_maps_complete_runtime_contract() { @@ -298,9 +298,10 @@ fn helius_laserstream_mainnet_and_devnet_api_key_map_to_protocol_and_safe_redact let mainnet_provenance = mainnet.effective().provenance_at("/ws_endpoints/1/url"); assert!(mainnet_provenance.is_some(), "Helius mainnet endpoint URL should retain secret environment provenance"); if let std::option::Option::Some(provenance) = mainnet_provenance { - assert_eq!(provenance.len(), 1); - assert_eq!(provenance[0].environment_source(), std::option::Option::Some(crate::ConfigEnvironmentSource::Process)); - assert_eq!(provenance[0].variable_name(), std::option::Option::Some("KSP_SECRET_HELIUS_API_KEY")); + assert_eq!(provenance.len(), 2); + assert_eq!(provenance[0], crate::ConfigValueProvenance::DocumentLiteral); + assert_eq!(provenance[1].environment_source(), std::option::Option::Some(crate::ConfigEnvironmentSource::Process)); + assert_eq!(provenance[1].variable_name(), std::option::Option::Some("KSP_SECRET_HELIUS_API_KEY")); } let devnet = engine.load_resolved_transport_config(std::option::Option::Some("helius_devnet"), &environment); assert!(devnet.is_ok(), "Helius devnet WebSocket endpoint should map without exposing its API key: {devnet:?}"); @@ -324,9 +325,10 @@ fn helius_laserstream_mainnet_and_devnet_api_key_map_to_protocol_and_safe_redact let devnet_provenance = devnet.effective().provenance_at("/ws_endpoints/0/url"); assert!(devnet_provenance.is_some(), "Helius devnet endpoint URL should retain secret environment provenance"); if let std::option::Option::Some(provenance) = devnet_provenance { - assert_eq!(provenance.len(), 1); - assert_eq!(provenance[0].environment_source(), std::option::Option::Some(crate::ConfigEnvironmentSource::Process)); - assert_eq!(provenance[0].variable_name(), std::option::Option::Some("KSP_SECRET_HELIUS_API_KEY")); + assert_eq!(provenance.len(), 2); + assert_eq!(provenance[0], crate::ConfigValueProvenance::DocumentLiteral); + assert_eq!(provenance[1].environment_source(), std::option::Option::Some(crate::ConfigEnvironmentSource::Process)); + assert_eq!(provenance[1].variable_name(), std::option::Option::Some("KSP_SECRET_HELIUS_API_KEY")); } let mainnet_debug = format!("{mainnet:?}"); let devnet_debug = format!("{devnet:?}"); diff --git a/deltas/0.2.8/pre.004-fix.002.md b/deltas/0.2.8/pre.004-fix.002.md new file mode 100644 index 0000000..3430acc --- /dev/null +++ b/deltas/0.2.8/pre.004-fix.002.md @@ -0,0 +1,139 @@ + + + +# Delta `0.2.8-pre.004-fix.002` — provenance Helius Config composée + +## 1. Objet + +Ce second fix de `pre.004` corrige uniquement une hypothèse erronée du canari Config Helius introduit par `pre.004-fix.001`. + +Le checkpoint opérateur prouve que : + +```text +fmt / audit / check / clippy verts +Transport vert +Config 109/110 +échec provenance.len() observé = 2, attendu = 1 +``` + +Le runtime Config, le schema, les profils Helius mainnet/devnet et le mapping Config -> Transport sont corrects et ne sont pas modifiés. + +Version workspace : + +```text +0.2.8-pre.4.fix.2 +``` + +Livraison / commit attendu : + +```text +0.2.8-pre.004-fix.002 +v0.2.8-pre.004-fix.002 +``` + +Aucun tag prerelease. + +## 2. Cause exacte + +L'URL Helius est une chaîne composée : + +```text +wss://mainnet.helius-rpc.com/?api-key=${KSP_SECRET_HELIUS_API_KEY:-...} +wss://devnet.helius-rpc.com/?api-key=${KSP_SECRET_HELIUS_API_KEY:-...} +``` + +Le modèle de provenance Config distingue les segments littéraux et les substitutions d'environnement. + +Avec une valeur fournie par le process, la provenance correcte est donc : + +```text +0 = ConfigValueProvenance::DocumentLiteral +1 = ConfigValueProvenance::EnvironmentProcess { + variable_name = KSP_SECRET_HELIUS_API_KEY + } +``` + +Le test de `fix.001` attendait à tort un seul segment, comme pour une valeur constituée uniquement d'un placeholder. + +## 3. Correction + +Le canari : + +```text +helius_laserstream_mainnet_and_devnet_api_key_map_to_protocol_and_safe_redaction +``` + +attend désormais, pour mainnet et devnet : + +```text +provenance.len() = 2 +provenance[0] = DocumentLiteral +provenance[1].environment_source() = Process +provenance[1].variable_name() = KSP_SECRET_HELIUS_API_KEY +``` + +Les assertions déjà présentes restent inchangées : + +```text +provider = helius +cluster = mainnet-beta / devnet +protocol = WsProtocolKind::HeliusLaserStream +runtime URL = vraie clé résolue +safe_value = URL avec api-key=******** +Debug = aucune clé réelle +``` + +## 4. Invariants non modifiés + +Aucune modification n'est apportée à : + +```text +ConfigEnvironment +ResolvedConfigJson / provenance implementation +sensitivity / redaction +config/schemas/std.transport.schema.json +config/std.transport.json +config/examples/std.transport.example.json +fixture std.transport.json +mapping helius_laserstream -> HeliusLaserStream +profils Helius mainnet/devnet +KSP_SECRET_HELIUS_API_KEY +WsEndpointUrl +WsSession / façades / actor +transactionSubscribe +heartbeat +dependencies +``` + +`pre.004-fix.001.md` reste immutable. + +## 5. Fichiers de la livraison + +Nouveau : + +```text +deltas/0.2.8/pre.004-fix.002.md +``` + +Modifiés : + +```text +Cargo.toml +crates/ksp-config-lib/unit_tests/transport.rs +docs/plans/015-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET_PLAN.md +docs/validation/011-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET.md +``` + +## 6. Validation à rejouer + +```bash +cargo fmt --all +python3 scripts/audit_rust_workspace_rules.py +cargo check --workspace +cargo clippy --workspace --all-targets +cargo test -p ksp-config-lib +cargo test -p ksp-onchain-transport-lib +cargo test --workspace +``` + +`pre.005` reste fermé jusqu'à réception de ce checkpoint intégralement vert. diff --git a/docs/plans/015-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET_PLAN.md b/docs/plans/015-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET_PLAN.md index 0b2d38f..8c1f2bc 100644 --- a/docs/plans/015-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET_PLAN.md +++ b/docs/plans/015-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET_PLAN.md @@ -1,9 +1,9 @@ - + # Plan `0.2.8` — Helius LaserStream WebSocket -> **Statut : `0.2.8-pre.003` est validé ; le checkpoint `0.2.8-pre.004` a révélé un faux négatif de test, puis la revue du fix a identifié l'omission d'une représentation Devnet Helius déterministe. `pre.004-fix.001` corrige les deux points et reste préparé.** Le runtime Config/Transport est inchangé : pour une chaîne composée, `safe_value` conserve les segments littéraux non sensibles et remplace uniquement le segment secret par `********`. Le fix couvre désormais mainnet et devnet sans ouvrir `transactionSubscribe`. +> **Statut : `0.2.8-pre.003` est validé ; `pre.004` est fonctionnellement implémenté mais son gate Config a nécessité deux corrections de canari. `pre.004-fix.001` a corrigé la redaction segmentaire et ajouté Devnet ; son checkpoint a ensuite révélé une seconde hypothèse de test erronée sur la provenance d'une chaîne composée. `pre.004-fix.002` corrige uniquement cette cardinalité/provenance et reste préparé.** Le runtime Config/Transport, les profils mainnet/devnet, le schema et le mapping Helius restent inchangés. ## 1. Objet, base et état courant @@ -28,10 +28,11 @@ pre.002 socle protocolaire validé pre.002-fix.001 correction Clippy + normalisation structure documentaire validées pre.003 six familles standard Helius validées pre.004 Config V2 Helius implémenté ; checkpoint bloqué par un faux négatif de test -pre.004-fix.001 correction safe_value + couverture Devnet Helius préparées +pre.004-fix.001 correction safe_value + couverture Devnet Helius ; checkpoint bloqué par provenance +pre.004-fix.002 correction du canari de provenance composée préparée -workspace.package.version courant = 0.2.8-pre.4.fix.1 -commit attendu = v0.2.8-pre.004-fix.001 +workspace.package.version courant = 0.2.8-pre.4.fix.2 +commit attendu = v0.2.8-pre.004-fix.002 aucun tag prerelease ``` @@ -53,8 +54,10 @@ pre.003 DONE — surface Helius standard supportée : account/logs/program/root + absence typée de block/slotsUpdates/vote sur Helius + non-régression standard 9/9 pre.004 CHECKPOINT — Config V2 helius_laserstream + schema/fixtures + mapping Config -> Transport + stratégie de secret Helius et redaction URL ; runtime/check/clippy/Transport verts - fix.001 PREPARED — corrige le faux négatif `safe_value` + complète la représentation Devnet Helius - + mainnet/devnet dans des profils distincts, même secret, sans changement runtime + fix.001 CHECKPOINT — redaction segmentaire corrigée + représentation Devnet Helius ajoutée + + gate Config bloqué uniquement par une attente de provenance `1` au lieu de `2` + fix.002 PREPARED — provenance composée attend `DocumentLiteral` + `EnvironmentProcess` + + aucun changement runtime/schema/fixture/profil pre.005 transactionSubscribe request typed + filters/options/tokenAccounts + transactionUnsubscribe + bounds 50k + maxSupportedTransactionVersion conditionnel pre.006 transactionNotification + actor integration + reconnect/resubscribe/unsubscribe races @@ -894,7 +897,7 @@ validation finale fermée prompt 0.2.9 prêt ``` -## 13. Checkpoint `pre.004` et `fix.001` +## 13. Checkpoints `pre.004`, `fix.001` et `fix.002` Le checkpoint `pre.003` est fermé par preuve opérateur : @@ -939,7 +942,27 @@ cargo test --workspace FAIL sur le même test Config L'unique échec opérateur compare `safe_value` à `********` alors que le résolveur produit correctement `wss://mainnet.helius-rpc.com/?api-key=********`. Les canaris historiques Config prouvent déjà ce contrat de redaction segmentaire pour les chaînes composées. La revue du fix a aussi identifié que `pre.004` ne matérialisait déterministiquement que mainnet alors que le contrat Helius WebSocket couvre mainnet et devnet. `pre.004-fix.001` corrige donc l'attente du test **et** ajoute un profil/fixture Devnet Helius séparé, sans modifier le résolveur, le schema, le mapping protocol ou le runtime Transport. -Le checkpoint à rejouer avant de déclarer `pre.004` + `fix.001` `DONE` est : +Le checkpoint opérateur de `pre.004-fix.001` reçu le 2026-08-23 confirme : + +```text +cargo fmt --all OK +python3 scripts/audit_rust_workspace_rules.py clean +cargo check --workspace OK +cargo clippy --workspace --all-targets OK +cargo test -p ksp-config-lib FAIL 109/110 +cargo test -p ksp-onchain-transport-lib OK 314 unit + 38 public + 26 completeness + 4 doctests +``` + +Le nouvel échec est strictement dans le canari Helius Config : + +```text +provenance observée = 2 segments +provenance attendue = 1 segment +``` + +Pour une URL composée `littéral + ${KSP_SECRET_HELIUS_API_KEY}`, le contrat Config enregistre correctement deux provenances ordonnées : `DocumentLiteral`, puis `EnvironmentProcess(KSP_SECRET_HELIUS_API_KEY)`. `pre.004-fix.002` corrige seulement cette attente pour mainnet et devnet ; aucune donnée Config ni logique runtime n'est modifiée. + +Le checkpoint à rejouer avant de déclarer `pre.004` + `fix.001` + `fix.002` `DONE` est : ```bash cargo fmt --all @@ -951,4 +974,4 @@ cargo test -p ksp-onchain-transport-lib cargo test --workspace ``` -Si ce checkpoint est vert, `pre.005` peut ouvrir la requête typed `transactionSubscribe` / `transactionUnsubscribe`, ses filtres/options et validations déterministes. +Si ce checkpoint est vert, `pre.004` et ses deux fixes peuvent être fermés, puis `pre.005` peut ouvrir la requête typed `transactionSubscribe` / `transactionUnsubscribe`, ses filtres/options et validations déterministes. diff --git a/docs/validation/011-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET.md b/docs/validation/011-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET.md index e5c2ac0..1f542b5 100644 --- a/docs/validation/011-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET.md +++ b/docs/validation/011-V0_2_8_HELIUS_LASERSTREAM_WEBSOCKET.md @@ -1,9 +1,9 @@ - + # Validation `0.2.8` — Helius LaserStream WebSocket -> **Statut : `pre.003` validé ; `pre.004` a atteint son checkpoint avec un faux négatif Config et la revue a ensuite relevé l'absence d'un cas Devnet Helius déterministe. `pre.004-fix.001` couvre les deux corrections.** `fmt`, audit, `check`, `clippy` et Transport sont verts. Le fix aligne le test Helius sur la redaction segmentaire existante et exige désormais mainnet + devnet dans des profils distincts. +> **Statut : `pre.003` validé ; `pre.004` est implémenté mais son gate Config a exposé deux hypothèses de test incorrectes. `pre.004-fix.001` a corrigé `safe_value` et ajouté Devnet ; son checkpoint est vert sur `fmt`, audit, `check`, `clippy` et Transport mais échoue encore sur la cardinalité de provenance. `pre.004-fix.002` corrige uniquement ce canari : une URL composée porte `DocumentLiteral` puis `EnvironmentProcess`.** ## 1. Références @@ -18,7 +18,8 @@ pre.002 deltas/0.2.8/pre.002.md pre.002 Clippy/docs fix deltas/0.2.8/pre.002-fix.001.md pre.003 deltas/0.2.8/pre.003.md pre.004 deltas/0.2.8/pre.004.md -pre.004 redaction test fix deltas/0.2.8/pre.004-fix.001.md +pre.004 redaction/devnet fix deltas/0.2.8/pre.004-fix.001.md +pre.004 provenance fix deltas/0.2.8/pre.004-fix.002.md validation standard WS docs/validation/010-V0_2_7_ONCHAIN_WEBSOCKET.md HTTP compliance docs/validation/007-V0_2_4_HTTP_FINAL_COMPLIANCE.md KSP-TRANSPORT-007 docs/validation/005-V0_2_3_KSP_TRANSPORT_007_RETRO_AUDIT.md @@ -338,7 +339,7 @@ Constats `pre.002-fix.001` : Aucun split en fichiers supplémentaires n'est retenu : les plans historiques `0.2.5`–`0.2.7` sont de taille comparable ou supérieure, et le contenu du plan `015` reste entièrement centré sur une seule release. Le problème identifié était **l'ordre interne et la duplication de responsabilités**, pas la nécessité d'un nouveau type de document. -## 12. Gate opérateur `pre.004` / `fix.001` +## 12. Gates opérateur `pre.004` / `fix.001` / `fix.002` Premier passage `pre.004` reçu le 2026-08-23 : @@ -361,7 +362,34 @@ attendu = ******** L'observé est conforme au contrat historique du résolveur Config : dans une chaîne composée, les littéraux non sensibles restent visibles dans la projection sûre tandis que chaque placeholder secret est remplacé par `********`. Le fix ne modifie donc pas le runtime ; il corrige le canari pour attendre l'URL sûre segmentaire exacte. La revue du même checkpoint complète également la couverture Config avec un profil Helius Devnet distinct utilisant `wss://devnet.helius-rpc.com/?api-key=...`, afin que mainnet et devnet soient tous deux prouvés sans mélange de clusters. -À rejouer après `pre.004-fix.001` : +Second passage reçu après `pre.004-fix.001` : + +```text +[x] cargo fmt --all +[x] python3 scripts/audit_rust_workspace_rules.py = clean +[x] cargo check --workspace +[x] cargo clippy --workspace --all-targets +[ ] cargo test -p ksp-config-lib — 109/110 ; provenance Helius composée attendue à tort sur 1 segment +[x] cargo test -p ksp-onchain-transport-lib — vert +``` + +Observation exacte : + +```text +provenance.len() observé = 2 +provenance.len() attendu = 1 +``` + +Le comportement runtime est correct. Une chaîne `wss://...api-key=${KSP_SECRET_HELIUS_API_KEY}` contient un segment littéral suivi d'un segment issu de l'environnement ; la provenance ordonnée doit donc être : + +```text +0 = DocumentLiteral +1 = EnvironmentProcess(KSP_SECRET_HELIUS_API_KEY) +``` + +`pre.004-fix.002` modifie uniquement le canari mainnet/devnet pour vérifier ces deux segments. Les profils, URLs, redaction, schema et mapping restent inchangés. + +À rejouer après `pre.004-fix.002` : ```text [ ] cargo fmt --all @@ -373,4 +401,4 @@ L'observé est conforme au contrat historique du résolveur Config : dans une ch [ ] cargo test --workspace ``` -Verdict courant : **`pre.003` DONE ; `pre.004` fonctionnellement implémenté mais non fermé ; `pre.004-fix.001` PREPARED.** +Verdict courant : **`pre.003` DONE ; `pre.004` fonctionnellement implémenté mais non fermé ; `pre.004-fix.001` CHECKPOINT ; `pre.004-fix.002` PREPARED.**